Merge branch 'feature/dae' into develop

# Conflicts:
#	pylot/core/io/data.py
#	pylot/core/util/widgets.py

.gitignore

@@ -0,0 +1,4 @@
+*.pyc
+*~
+.idea
+pylot/RELEASE-VERSION

README.md

@@ -1,2 +1,111 @@
-# PyLoT
+# PyLoT
-Python picking and Location Tool
+
+version: 0.3
+
+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 PySide2 Qt5 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.
+
+It is highly recommended to use Anaconda for a simple creation of a Python installation using either the *pylot.yml* or the *requirements.txt* file found in the PyLoT root directory. First make sure that the *conda-forge* channel is available in your Anaconda installation:
+
+    conda config --add channels conda-forge
+
+Afterwards run (from the PyLoT main directory where the files *requirements.txt* and *pylot.yml* are located)
+
+    conda env create -f pylot.yml
+or
+    
+    conda create --name pylot_38 --file requirements.txt
+
+to create a new Anaconda environment called "pylot_38".
+
+Afterwards activate the environment by typing
+
+    conda activate pylot_38
+
+#### Prerequisites:
+
+In order to run PyLoT you need to install:
+
+- Python 3
+- obspy
+- pyside2
+- pyqtgraph
+- cartopy
+
+(the following are already dependencies of the above packages):
+- scipy
+- numpy
+- matplotlib <= 3.3.x
+
+#### 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:
+
+- event organisation in project files and waveform visualisation
+- consistent manual phase picking through predefined SNR dependant zoom level
+- consistent automatic phase picking routines using Higher Order Statistics, AIC and Autoregression
+- interactive tuning of auto-pick parameters
+- 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:
+
+We hope to solve these with the next release.
+
+## Staff
+
+Original author(s): M. Rische, S. Wehling-Benatelli, L. Kueperkoch, M. Bischoff (PILOT)
+
+Developer(s): S. Wehling-Benatelli, M. Paffrath, L. Kueperkoch, K. Olbert, M. Bischoff, C. Wollin, M. Rische, D. Arnold, K. Cökerim, S. Zimmermann
+
+Others: A. Bruestle, T. Meier, W. Friederich
+
+
+[ObsPy]: http://github.com/obspy/obspy/wiki
+
+April 2022

autoPyLoT.py

@@ -0,0 +1,561 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from __future__ import print_function
+
+import argparse
+import datetime
+import glob
+import os
+import traceback
+
+from obspy import read_events
+from obspy.core.event import ResourceIdentifier
+
+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
+import pylot.core.loc.velest as velest
+# 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 PylotParameter
+from pylot.core.pick.autopick import autopickevent, iteratepicker
+from pylot.core.util.dataprocessing import restitute_data, 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 get_none, trim_station_components, check4gapsAndRemove, check4doubled, \
+    check4rotated
+from pylot.core.util.version import get_git_version as _getVersionString
+
+__version__ = _getVersionString()
+
+
+def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, eventid=None, savepath=None,
+              savexml=True, station='all', iplot=0, ncores=0, obspyDMT_wfpath=False):
+    """
+    Determine phase onsets automatically utilizing the automatic picking
+    algorithms by Kueperkoch et al. 2010/2012.
+    :param obspyDMT_wfpath: if obspyDMT is used, name of data directory ("raw" or "processed")
+    :param input_dict:
+    :type input_dict:
+    :param parameter: PylotParameter object containing parameters used for automatic picking
+    :type parameter: pylot.core.io.inputs.PylotParameter
+    :param inputfile: path to the input file containing all parameter information for automatic picking
+    (for formatting details, see. `~pylot.core.io.inputs.PylotParameter`
+    :type inputfile: str
+    :param fnames: list of data file names or None when called from GUI
+    :type fnames: str
+    :param eventid: event path incl. event ID (path to waveform files)
+    :type eventid: str
+    :param savepath: save path for autoPyLoT output, if None/"None" output will be saved in event folder
+    :type savepath: str
+    :param savexml: export results in XML file if True
+    :type savexml: bool
+    :param station: choose specific station name or 'all' to pick all stations
+    :type station: str
+    :param iplot: logical variable for plotting: 0=none, 1=partial, 2=all
+    :type iplot: int
+    :param ncores: number of cores used for parallel processing. Default (0) uses all available cores
+    :type ncores: int
+    :return: dictionary containing picks
+    :rtype: dict
+    """
+
+    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} 2017\n
+                \n
+                Authors:\n
+                L. Kueperkoch (BESTEC GmbH, Landau i. d. Pfalz, \n
+                   now at igem GmbH, Mainz)
+                M. Paffrath (Ruhr-Universitaet Bochum)\n
+                S. Wehling-Benatelli (Ruhr-Universitaet Bochum)\n
+                
+                {sp}
+                ***********************************'''.format(version=_getVersionString(),
+                                                              sp=sp_info)
+    print(splash)
+
+    parameter = get_none(parameter)
+    inputfile = get_none(inputfile)
+    eventid = get_none(eventid)
+
+    fig_dict = None
+    fig_dict_wadatijack = None
+
+    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 'savexml' in input_dict:
+            savexml = input_dict['savexml']
+        if 'obspyDMT_wfpath' in input_dict:
+            obspyDMT_wfpath = input_dict['obspyDMT_wfpath']
+
+    if not parameter:
+        if not inputfile:
+            print('Using default input parameter')
+        parameter = PylotParameter(inputfile)
+    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
+
+    # 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'),
+                    'dbase': parameter.get('database')}
+
+        exf = ['root', 'dpath', 'dbase']
+
+        if parameter['eventID'] != '*' and fnames == 'None':
+            dsfields['eventID'] = parameter['eventID']
+            exf.append('eventID')
+
+        datastructure.modifyFields(**dsfields)
+        datastructure.setExpandFields(exf)
+
+        # check if default location routine NLLoc is available and all stations are used
+        if get_none(parameter['nllocbin']) and station == 'all':
+            locflag = 1
+            # get NLLoc-root path
+            nllocroot = parameter.get('nllocroot')
+            # get path to NLLoc executable
+            nllocbin = parameter.get('nllocbin')
+            nlloccall = '%s/NLLoc' % nllocbin
+            # get name of phase file
+            phasef = parameter.get('phasefile')
+            phasefile = '%s/obs/%s' % (nllocroot, phasef)
+            # get name of NLLoc-control file
+            ctrf = parameter.get('ctrfile')
+            ctrfile = '%s/run/%s' % (nllocroot, ctrf)
+            # pattern of NLLoc ttimes from location grid
+            ttpat = parameter.get('ttpatter')
+            # pattern of NLLoc-output file
+            nllocoutpatter = parameter.get('outpatter')
+            maxnumit = 2  # maximum number of iterations for re-picking
+        else:
+            locflag = 0
+            print("                 !!!              ")
+            print("!!No location routine available, autoPyLoT is running in non-location mode!!")
+            print("!!No source parameter estimation possible!!")
+            print("                 !!!              ")
+
+        wfpath_extension = ''
+        if obspyDMT_wfpath not in [None, False, 'False', '']:
+            wfpath_extension = obspyDMT_wfpath
+            print('Using obspyDMT structure. There will be no restitution, as pre-processed data are expected.')
+            if wfpath_extension != 'processed':
+                print('WARNING: Expecting wfpath_extension to be "processed" for'
+                      ' pre-processed data but received "{}" instead!!!'.format(wfpath_extension))
+
+        if not input_dict:
+            # started in production mode
+            datapath = datastructure.expandDataPath()
+            if fnames == 'None' and parameter['eventID'] == '*':
+                # multiple event processing
+                # read each event in database
+                events = [event for event in glob.glob(os.path.join(datapath, '*')) if
+                          (os.path.isdir(event) and not event.endswith('EVENTS-INFO'))]
+            elif fnames == 'None' and parameter['eventID'] != '*' 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 = [eventid]
+                evID = os.path.split(eventid)[-1]
+                locflag = 2
+        else:
+            # 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
+
+        nEvents = len(events)
+        for index, eventpath in enumerate(events):
+            print('Working on: {} ({}/{})'.format(eventpath, index + 1, nEvents))
+            evID = os.path.split(eventpath)[-1]
+            event_datapath = os.path.join(eventpath, wfpath_extension)
+            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, event_datapath, '*')))
+                # the following is necessary because within
+                # multiple event processing no event ID is provided
+                # in autopylot.in
+                try:
+                    parameter.get('eventID')
+                except Exception:
+                    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)
+            # trim components for each station to avoid problems with different trace starttimes for one station
+            wfdat = check4gapsAndRemove(wfdat)
+            wfdat = check4doubled(wfdat)
+            wfdat = trim_station_components(wfdat, trim_start=True, trim_end=False)
+            if not wfpath_extension:
+                metadata = Metadata(parameter.get('invdir'))
+            else:
+                metadata = Metadata(os.path.join(eventpath, 'resp'))
+            corr_dat = None
+            if metadata:
+                # rotate stations to ZNE
+                try:
+                    wfdat = check4rotated(wfdat, metadata)
+                except Exception as e:
+                    print('Could not rotate station {} to ZNE:\n{}'.format(wfdat[0].stats.station,
+                                                                           traceback.format_exc()))
+                if locflag:
+                    print("Restitute data ...")
+                    corr_dat = restitute_data(wfdat.copy(), metadata, ncores=ncores)
+            if not corr_dat and locflag:
+                locflag = 2
+            print('Stations: %s' % (station))
+            print(wfdat)
+            ##########################################################
+            # !automated picking starts here!
+            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 > 0:
+                # write phases to NLLoc-phase file
+                nll.export(picks, phasefile, parameter)
+
+                # For locating the event the NLLoc-control file has to be modified!
+                nllocout = '%s_%s' % (evID, nllocoutpatter)
+                # create comment line for NLLoc-control file
+                nll.modify_inputs(ctrf, nllocroot, nllocout, phasef,
+                                  ttpat)
+
+                # locate the event
+                nll.locate(ctrfile, parameter)
+
+                # !iterative picking if traces remained unpicked or occupied with bad picks!
+                # get theoretical onset times for picks with weights >= 4
+                # in order to reprocess them using smaller time windows around theoretical onset
+                # get stations with bad onsets
+                badpicks = []
+                for key in picks:
+                    if picks[key]['P']['weight'] >= 4 or picks[key]['S']['weight'] >= 4:
+                        badpicks.append([key, picks[key]['P']['mpp']])
+
+                # TODO keep code DRY (Don't Repeat Yourself) the following part is written twice
+                # suggestion: delete block and modify the later similar block to work properly
+
+                if len(badpicks) == 0:
+                    print("autoPyLoT: No bad onsets found, thus no iterative picking necessary!")
+                    # get NLLoc-location file
+                    locsearch = '%s/loc/%s.????????.??????.grid?.loc.hyp' % (nllocroot, nllocout)
+                    if len(glob.glob(locsearch)) > 0:
+                        # get latest NLLoc-location file if several are available
+                        nllocfile = max(glob.glob(locsearch), key=os.path.getctime)
+                        evt = read_events(nllocfile)[0]
+                        # 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():
+                            picks[stats]['P'].update(props)
+                        evt = moment_mag.updated_event()
+                        net_mw = moment_mag.net_magnitude()
+                        if net_mw is not None:
+                            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)
+                        # update pick with local magnitude property values
+                        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)
+                        if net_ml:
+                            print("Network local magnitude: %4.1f" % net_ml.mag)
+                        if magscaling is None:
+                            scaling = False
+                        elif magscaling[0] != 0 and magscaling[1] != 0:
+                            scaling = False
+                        else:
+                            scaling = True
+                        if scaling:
+                            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)
+                    if len(glob.glob(locsearch)) > 0:
+                        # get latest file if several are available
+                        nllocfile = max(glob.glob(locsearch), key=os.path.getctime)
+                        nlloccounter = 0
+                        while len(badpicks) > 0 and nlloccounter <= maxnumit:
+                            nlloccounter += 1
+                            if nlloccounter > maxnumit:
+                                print("autoPyLoT: Number of maximum iterations reached, stop iterative picking!")
+                                break
+                            print("autoPyLoT: Starting with iteration No. %d ..." % nlloccounter)
+                            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, parameter)
+                            # remove actual NLLoc-location file to keep only the last
+                            os.remove(nllocfile)
+                            # locate the event
+                            nll.locate(ctrfile, parameter)
+                            print("autoPyLoT: Iteration No. %d finished." % nlloccounter)
+                            # get updated NLLoc-location file
+                            nllocfile = max(glob.glob(locsearch), key=os.path.getctime)
+                            # check for bad picks
+                            badpicks = []
+                            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,
+                                                                                                  len(badpicks)))
+                            if len(badpicks) == 0:
+                                print("autoPyLoT: No more bad onsets found, stop iterative picking!")
+                                nlloccounter = maxnumit
+                        evt = read_events(nllocfile)[0]
+                        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 stats in picks:
+                                    picks[stats]['P'].update(props)
+                            evt = moment_mag.updated_event()
+                            net_mw = moment_mag.net_magnitude()
+                            if net_mw is not None:
+                                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)
+                            # update pick with local magnitude property values
+                            for stats, amplitude in local_mag.amplitudes.items():
+                                if stats in picks:
+                                    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)
+                            if net_ml:
+                                print("Network local magnitude: %4.1f" % net_ml.mag)
+                            if magscaling is None:
+                                scaling = False
+                            elif magscaling[0] != 0 and magscaling[1] != 0:
+                                scaling = False
+                            else:
+                                scaling = True
+                            if scaling:
+                                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 
+            # 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')
+            data.applyEVTData(picks)
+            if savexml:
+                if savepath == 'None' or savepath is None:
+                    saveEvtPath = eventpath
+                else:
+                    saveEvtPath = savepath
+                fnqml = '%s/PyLoT_%s_autopylot' % (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__":
+    # parse arguments
+    parser = argparse.ArgumentParser(
+        description='''autoPyLoT automatically picks phase onset times using higher order statistics,
+                       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''')
+    parser.add_argument('-p', '-P', '--iplot', type=int,
+                        action='store', default=0,
+                        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))''')
+    parser.add_argument('-dmt', '-DMT', '--obspy_dmt_wfpath', type=str,
+                        action='store', default=False,
+                        help='''optional, wftype (raw, processed) used for obspyDMT database structure''')
+
+    cla = parser.parse_args()
+
+    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), obspyDMT_wfpath=str(cla.obspy_dmt_wfpath))

autopylot.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+#$ -l low
+#$ -cwd
+#$ -pe smp 40
+##$ -l mem=3G
+#$ -l h_vmem=6G
+#$ -l os=*stretch
+
+conda activate pylot_311
+
+python ./autoPyLoT.py -i /home/marcel/.pylot/pylot_adriaarray.in -c 20 -dmt processed

docs/gui.md

@@ -0,0 +1,474 @@
+# PyLoT Documentation
+
+- [PyLoT Documentation](#pylot-documentation)
+- [PyLoT GUI](#pylot-gui)
+    - [First start](#first-start)
+    - [Main Screen](#main-screen)
+        - [Waveform Plot](#waveform-plot)
+            - [Mouse view controls](#mouse-view-controls)
+            - [Buttons](#buttons)
+        - [Array Map](#array-map)
+        - [Eventlist](#eventlist)
+    - [Usage](#usage)
+        - [Projects and Events](#projects-and-events)
+        - [Event folder structure](#event-folder-structure)
+        - [Loading event information from CSV file](#loading-event-information-from-csv-file)
+        - [Adding events to project](#adding-events-to-project)
+        - [Saving projects](#saving-projects)
+        - [Adding metadata](#adding-metadata)
+- [Picking](#picking)
+    - [Manual Picking](#manual-picking)
+        - [Picking window](#picking-window)
+            - [Picking Window Settings](#picking-window-settings)
+        - [Filtering](#filtering)
+        - [Export and Import of manual picks](#export-and-import-of-manual-picks)
+            - [Export](#export)
+            - [Import](#import)
+    - [Automatic Picking](#automatic-picking)
+        - [Tuning](#tuning)
+        - [Production run of the autopicker](#production-run-of-the-autopicker)
+        - [Evaluation of automatic picks](#evaluation-of-automatic-picks)
+            - [1. Jackknife check](#1-jackknife-check)
+            - [2. Wadati check](#2-wadati-check)
+        - [Comparison between automatic and manual picks](#comparison-between-automatic-and-manual-picks)
+        - [Export and Import of automatic picks](#export-and-import-of-automatic-picks)
+- [Location determination](#location-determination)
+- [FAQ](#faq)
+
+# PyLoT GUI
+
+This section describes how to use PyLoT graphically to view waveforms and create manual or automatic picks.
+
+## First start
+
+After opening PyLoT for the first time, the setup routine asks for the following information:
+
+Questions:
+
+1. Full Name
+2. Authority: Enter authority/institution name
+3. Format: Enter output format (*.xml, *.cnv, *.obs)
+
+[//]: <> (TODO: explain what these things mean, where they are used)
+
+## Main Screen
+
+After entering the [information](#first-start), PyLoTs main window is shown. It defaults to a view of
+the [Waveform Plot](#waveform-plot), which starts empty.
+
+<img src=images/gui/pylot-main-screen.png alt="Tune autopicks button" title="Tune autopicks button">
+
+Add trace data by [loading a project](#projects-and-events) or by [adding event data](#adding-events-to-project).
+
+### Waveform Plot
+
+The waveform plot shows a trace list of all stations of an event.   
+Click on any trace to open the stations [picking window](#picking-window), where you can review automatic and manual
+picks.
+
+<img src=images/gui/pylot-waveform-plot.png alt="A Waveform Plot showing traces of one event">
+
+Above the traces the currently displayed event can be selected. In the bottom bar information about the trace under the
+mouse cursor is shown. This information includes the station name (station), the absolute UTC time (T) of the point
+under the mouse cursor and the relative time since the first trace start in seconds (t) as well as a trace count.
+
+#### Mouse view controls
+
+Hold left mouse button and drag to pan view.
+
+Hold right mouse button and Direction | Result --- | --- Move the mouse up | Increase amplitude scale Move the mouse
+down | Decrease amplitude scale Move the mouse right | Increase time scale Move the mouse left | Decrease time scale
+
+Press right mouse button and click "View All" from the context menu to reset the view.
+
+#### Buttons
+
+[//]: <> (Hack: We need these invisible spaces to add space to the first column, otherwise )
+
+| Icon &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; | Description                                                                                                                                                                                                                                                                                                                                                                                                |
+|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| <img src="../icons/newfile.png" alt="Create new project" width="64" height="64">                                                                                                   | Create a new project, for more information about projects see [Projects and Events](#projects-and-events).                                                                                                                                                                                                                                                                                                 |
+| <img src="../icons/openproject.png" alt="Open project" width="64" height="64">                                                                                                     | Load a project file from disk.                                                                                                                                                                                                                                                                                                                                                                             |
+| <img src="../icons/saveproject.png" alt="Save Project" width="64" height="64">                                                                                                     | Save all current events into an associated project file on disk. If there is no project file currently associated, you will be asked to create a new one.                                                                                                                                                                                                                                                  |
+| <img src="../icons/saveprojectas.png" alt="Save Project as" width="64" height="64">                                                                                                | Save all current events into a new project file on disk. See [Saving projects](#saving-projects).                                                                                                                                                                                                                                                                                                          |
+| <img src="../icons/add.png" alt="Add event data" width="64" height="64">                                                                                                           | Add event data by selecting directories containing waveforms. For more information see [Event folder structure](#event-folder-structure).                                                                                                                                                                                                                                                                  |
+| <img src="../icons/openpick.png" alt="Load event information" width="64" height="64">                                                                                              | Load picks/origins from disk into the currently displayed event. If a pick already exists for a station, the one from file will overwrite the existing one.                                                                                                                                                                                                                                                |
+| <img src="../icons/openpicks.png" alt="Load information for all events" width="64" height="64">                                                                                    | Load picks/origins for all events of the current project. PyLoT searches for files within the directory of the event and tries to load them for that event. For this function to work, the files containing picks/origins have to be named as described in [Event folder   structure](#event-folder-structure). If a pick already exists for a station, the one from file will overwrite the existing one. |
+| <img src="../icons/savepicks.png" alt="Save picks" width="64" height="64">                                                                                                         | Save event information such as picks and origin to file. You will be asked to select a directory in which this information should be saved.                                                                                                                                                                                                                                                                |
+| <img src="../icons/openloc.png" alt="Load location information" width="64" height="64">                                                                                            | Load location information from disk,                                                                                                                                                                                                                                                                                                                                                                       |
+| <img src="../icons/Matlab_PILOT_icon.png" alt="Load legacy information" width="64" height="64">                                                                                    | Load event information from a previous, MatLab based PILOT version.                                                                                                                                                                                                                                                                                                                                        |
+| <img src="../icons/key_Z.png" alt="Display Z" width="64" height="64">                                                                                                              | Display Z component of streams in waveform plot.                                                                                                                                                                                                                                                                                                                                                           |
+| <img src="../icons/key_N.png" alt="Display N" width="64" height="64">                                                                                                              | Display N component of streams in waveform plot.                                                                                                                                                                                                                                                                                                                                                           |
+| <img src="../icons/key_E.png" alt="Display E" width="64" height="64">                                                                                                              | Display E component of streams in waveform plot.                                                                                                                                                                                                                                                                                                                                                           |
+| <img src="../icons/tune.png" alt="Tune Autopicker" width="64" height="64">                                                                                                         | Open the [Tune Autopicker window](#tuning).                                                                                                                                                                                                                                                                                                                                                                |
+| <img src="../icons/autopylot_button.png" alt="" width="64" height="64">                                                                                                            | Opens a window that allows starting the autopicker for all events ([Production run of the AutoPicker](#production-run-of-the-autopicker)).                                                                                                                                                                                                                                                                 |
+| <img src="../icons/compare_button.png" alt="Comparison" width="64" height="64">                                                                                                    | Compare automatic and manual picks, only available if automatic and manual picks for an event exist. See [Comparison between automatic and manual picks](#comparison-between-automatic-and-manual-picks).                                                                                                                                                                                                  |
+| <img src="../icons/locate_button.png" alt="Locate event" width="64" height="64">                                                                                                   | Run a location routine (NonLinLoc) as configured in the settings on the picks. See [Location determination](#location-determination).                                                                                                                                                                                                                                                                      |
+
+### Array Map
+
+The array map will display a color diagram to allow a visual check of the consistency of picks across multiple stations.
+This works by calculating the time difference of every onset to the earliest onset. Then isolines are drawn between
+stations with the same time difference and the areas between isolines are colored.  
+The result should resemble a color gradient as the wavefront rolls over the network area. Stations where picks are
+earlier/later than their neighbours can be reviewed by clicking on them, which opens
+the [picking window](#picking-window).
+
+Above the Array Map the picks that are used to create the map can be customized. The phase of picks that should be used
+can be selected, which allows checking the consistency of the P- and S-phase separately. Additionally the pick type can
+be set to manual, automatic or hybrid, meaning display only manual picks, automatic picks or only display automatic
+picks for stations where there are no manual ones.
+
+![Array Map](images/gui/arraymap-example.png "Array Map")  
+*Array Map for an event at the Northern Mid Atlantic Ridge, between North Africa and Mexico (Lat. 22.58, Lon. -45.11).
+The wavefront moved from west to east over the network area (Alps and Balcan region), with the earliest onsets in blue
+in the west.*
+
+To be able to display an array map PyLoT needs to load an inventory file, where the metadata of seismic stations is
+kept. For more information see [Metadata](#adding-metadata). Additionally automatic or manual picks need to exist for
+the current event.
+
+### Eventlist
+
+The eventlist displays event parameters. The displayed parameters are saved in the .xml file in the event folder. Events
+can be deleted from the project by pressing the red X in the leftmost column of the corresponding event.
+
+<img src="images/gui/eventlist.png" alt="Eventlist">
+
+| Column     | Description                                                                                                        |
+|------------|--------------------------------------------------------------------------------------------------------------------|
+| Event      | Full path to the events folder.                                                                                    |
+| Time       | Time of event.                                                                                                     |
+| Lat        | Latitude in degrees of event location.                                                                             |
+| Lon        | Longitude in degrees of event location.                                                                            |
+| Depth      | Depth in km of event.                                                                                              |
+| Mag        | Magnitude of event.                                                                                                |
+| [N] MP     | Number of manual picks.                                                                                            |
+| [N] AP     | Number of automatic picks.                                                                                         |
+| Tuning Set | Select whether this event is a Tuning event. See [Automatic Picking](#automatic-picking).                          |
+| Test Set   | Select whether this event is a Test event. See [Automatic Picking](#automatic-picking).                            |
+| Notes      | Free form text field for notes regarding this event. Text will be saved in the notes.txt file in the event folder. |
+
+## Usage
+
+### Projects and Events
+
+PyLoT uses projects to categorize different seismic data. A project consists of one or multiple events. Events contain
+seismic traces from one or multiple stations. An event also contains further information, e.g. origin time, source
+parameters and automatic as well as manual picks. Projects are used to group events which should be analysed together. A
+project could contain all events from a specific region within a timeframe of interest or all recorded events of a
+seismological experiment.
+
+### Event folder structure
+
+PyLoT expects the following folder structure for seismic data:
+
+* Every event should be in it's own folder with the following naming scheme for the folders:
+  ``e[id].[doy].[yy]``, where ``[id]`` is a four-digit numerical id increasing from 0001, ``[doy]`` the three digit day
+  of year and ``[yy]`` the last two digits of the year of the event. This structure has to be created by the user of
+  PyLoT manually.
+* These folders should contain the seismic data for their event as ``.mseed`` or other supported filetype
+* All automatic and manual picks should be in an ``.xml`` file in their event folder. PyLoT saves picks in this file.
+  This file does not have to be added manually unless there are picks to be imported. The format used to save picks is
+  QUAKEML.   
+  Picks are saved in a file with the same filename as the event folder with ``PyLoT_`` prepended.
+* The file ``notes.txt`` is used for saving analysts comments. Everything saved here will be displayed in the 'Notes'
+  column of the eventlist.
+
+### Loading event information from CSV file
+
+Event information can be saved in a ``.csv`` file located in the rootpath. The file is made from one header line, which
+is followed by one or multiple data lines. Values are separated by comma, while a dot is used as a decimal separator.   
+This information is then shown in the table in the [Eventlist tab](#Eventlist).
+
+One example header and data line is shown below.
+```event,Date,Time,Magnitude,Lat,Long,Depth,Region,Basis Lat,Basis Long,Distance [km],Distance [rad],Distance [deg]```   
+```e0001.024.16,24/01/16,10:30:30,7.1,59.66,-153.45,128,Southern Alaska,46.62,10.26,8104.65,1.27,72.89,7.1```
+
+The meaning of the header entries is:
+
+| Header               | description                                                                                    |
+|----------------------|------------------------------------------------------------------------------------------------|
+| event                | Event id, has to be the same as the folder name in which waveform data for this event is kept. |
+| Data                 | Origin date of the event, format DD/MM/YY or DD/MM/YYYY.                                       |
+| Time                 | Origin time of the event. Format HH:MM:SS.                                                     |
+| Lat, Long            | Origin latitude and longitude in decimal degrees.                                              |
+| Region               | Flinn-Engdahl region name.                                                                     |
+| Basis Lat, Basis Lon | Latitude and longitude of the basis of the station network in decimal degrees.                 |
+| Distance [km]        | Distance from origin coordinates to basis coordinates in km.                                   |
+| Distance [rad]       | Distance from origin coordinates to basis coordinates in rad.                                  |
+
+### Adding events to project
+
+PyLoT GUI starts with an empty project. To add events, use the add event data button. Select one or multiple folders
+containing events.
+
+[//]: <> (TODO: explain _Directories: Root path, Data path, Database path_)
+
+### Saving projects
+
+Save the current project from the menu with File->Save project or File->Save project as. PyLoT uses ``.plp`` files to
+save project information. This file format is not interchangeable between different versions of Python interpreters.
+Saved projects contain the automatic and manual picks. Seismic trace data is not included into the ``.plp`` file, but
+read from its location used when saving the file.
+
+### Adding metadata
+
+[//]: <> (TODO: Add picture of metadata "manager" when it is done)
+
+PyLoT can handle ``.dless``, ``.xml``, ``.resp`` and ``.dseed`` file formats for Metadata. Metadata files stored on disk
+can be added to a project by clicking *Edit*->*Manage Inventories*. This opens up a window where the folders which
+contain metadata files can be selected. PyLoT will then search these files for the station names when it needs the
+information.
+
+# Picking
+
+PyLoTs automatic and manual pick determination works as following:
+
+* Using certain parameters, a first initial/coarse pick is determined. The first manual pick is determined by visual
+  review of the whole waveform and selection of the most likely onset by the analyst. The first automatic pick is
+  determined by calculation of a characteristic function (CF) for the seismic trace. When a wave arrives, the CFs
+  properties change, which is determined as the signals onset.
+* Afterwards, a refined set of parameters is applied to a small part of the waveform around the initial onset. For
+  manual picks this means a closer view of the trace, for automatic picks this is done by a recalculated CF with
+  different parameters.
+* This second picking phase results in the precise pick, which is treated as the onset time.
+
+## Manual Picking
+
+To create manual picks, you will need to open or create a project that contains seismic trace data (
+see [Adding events to projects](#adding-events-to-project)). Click on a trace to open
+the [Picking window](#picking-window).
+
+### Picking window
+
+Open the picking window of a station by leftclicking on any trace in the waveform plot. Here you can create manual picks
+for the selected station.
+
+<img src="images/gui/picking/pickwindow.png" alt="Picking window">
+
+*Picking window of a station.*
+
+#### Picking Window Settings
+
+| Icon                                                                             | Shortcut       | Menu Alternative            | Description                                                                                                                                                                                                         |
+|----------------------------------------------------------------------------------|----------------|-----------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| <img src="../icons/filter_p.png" alt="Filter P" width="64" height="64">          | p              | Filter->Apply P Filter      | Filter all channels according to the options specified in Filter parameter, P Filter section.                                                                                                                       |
+| <img src="../icons/filter_s.png" alt="Filter S" width="64" height="64">          | s              | Filter->Apply S Filter      | Filter all channels according to the options specified in Filter parameter, S Filter section.                                                                                                                       |
+| <img src="../icons/key_A.png" alt="Filter Automatically" width="64" height="64"> | Ctrl + a       | Filter->Automatic Filtering | If enabled, automatically select the correct filter option (P, S) depending on the selected phase to be picked.                                                                                                     |
+| ![desc](images/gui/picking/phase_selection.png "Phase selection")                | 1 (P) or 5 (S) | Picks->P or S               | Select phase to pick. If Automatic Filtering is enabled, this will apply the appropriate filter depending on the phase.                                                                                             |
+| ![Zoom into](../icons/zoom_in.png "Zoom into waveform")                          | -              | -                           | Zoom into waveform.                                                                                                                                                                                                 |
+| ![Reset zoom](../icons/zoom_0.png "Reset zoom")                                  | -              | -                           | Reset zoom to default view.                                                                                                                                                                                         |
+| ![Delete picks](../icons/delete.png "Delete picks")                              | -              | -                           | Delete all manual picks on this station.                                                                                                                                                                            |
+| ![Rename a phase](../icons/sync.png "Rename a phase")                            | -              | -                           | Click this button and then the picked phase to rename it.                                                                                                                                                           |
+| ![Continue](images/gui/picking/continue.png "Continue with next station")        | -              | -                           | If checked, after accepting the manual picks for this station with 'OK', the picking window for the next station will be opened. This option is useful for fast manual picking of a complete event.                 |
+| Estimated onsets                                                                 | -              | -                           | Show the theoretical onsets for this station. Needs metadata and origin information.                                                                                                                                |
+| Compare to channel                                                               | -              | -                           | Select a data channel to compare against. The selected channel will be displayed in the picking window behind every channel allowing the analyst to visually compare signal correlation between different channels. |
+| Scaling                                                                          | -              | -                           | Individual means every channel is scaled to its own maximum. If a channel is selected here, all channels will be scaled relatively to this channel.                                                                 |
+
+| Menu Command              | Shortcut | Description                                                                                                                                                                                                                                                                 |
+|---------------------------|----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| P Channels and S Channels | -        | Select which channels should be treated as P or S channels during picking. When picking a phase, only the corresponding channels will be shown during the precise pick. Normally, the Z channel should be selected for the P phase and the N and E channel for the S phase. |
+
+### Filtering
+
+Access the Filter options by pressing Ctrl+f on the Waveform plot or by the menu under *Edit*->*Filter Parameter*.
+
+<img src=images/gui/pylot-filter-options.png>
+
+Here you are able to select filter type, order and frequencies for the P and S pick separately. These settings are used
+in the GUI for displaying the filtered waveform data and during manual picking. The values used by PyLoT for automatic
+picking are displayed next to the manual values. They can be changed in the [Tune Autopicker dialog](#tuning).  
+A green value automatic value means the automatic and manual filter parameter is configured the same, red means they are
+configured differently. By toggling the "Overwrite filteroptions" checkmark you can set whether the manual
+precise/second pick uses the filter settings for the automatic picker (unchecked) or whether it uses the filter options
+in this dialog (checked). To guarantee consistent picking results between automatic and manual picking it is recommended
+to use the same filter settings for the determination of automatic and manual picks.
+
+### Export and Import of manual picks
+
+#### Export
+
+After the creation of manual picks they can either be saved in the project file (
+see [Saving projects](#saving-projects)). Alternatively the picks can be exported by pressing
+the <img src="../icons/savepicks.png" alt="Save event information button" title="Save picks button" height=24 width=24>
+button above the waveform plot or in the menu File->Save event information (shortcut Ctrl+p). Select the event directory
+in which to save the file. The filename will be ``PyLoT_[event_folder_name].[filetype selected during first startup]``
+.     
+You can rename and copy this file, but PyLoT will then no longer be able to automatically recognize the correct picks
+for an event and the file will have to be manually selected when loading.
+
+#### Import
+
+To import previously saved picks press
+the <img src="../icons/openpick.png" alt="Load event information button" width="24" height="24"> button and select the
+file to load. You will be asked to save the current state of your project if you have not done so before. You can
+continue without saving by pressing "Discard". This does not delete any information from your project, it just means
+that no project file is saved before the changes of importing picks are applied. PyLoT will automatically load files
+named after the scheme it uses when saving picks, described in the paragraph above. If it can't find any matching files,
+a file dialogue will open and you can select the file you wish to load.
+
+If you see a warning "Mismatch in event identifiers" and are asked whether to continue loading the picks, this means
+that PyLoT doesn't recognize the picks in the file as belonging to this specific event. They could have either been
+saved under a different installation of PyLoT but with the same waveform data, which means they are still compatible and
+you can continue loading them. Or they could be picks from a different event, in which case loading them is not
+recommended.
+
+## Automatic Picking
+
+The general workflow for automatic picking is as following:
+
+- After setting up the project by loading waveforms and optionally metadata, the right parameters for the autopicker
+  have to be determined
+- This [tuning](#tuning) is done for single stations with immediate graphical feedback of all picking results
+- Afterwards the autopicker can be run for all or a subset of events from the project
+
+For automatic picking PyLoT discerns between tune and test events, which the user has to set as such. Tune events are
+used to calibrate the autopicking algorithm, test events are then used to test the calibration. The purpose of that is
+controlling whether the parameters found during tuning are able to reliably pick the "unknown" test events.  
+If this behaviour is not desired and all events should be handled the same, dont mark any events. Since this is just a
+way to group events to compare the picking results, nothing else will change.
+
+### Tuning
+
+Tuning describes the process of adjusting the autopicker settings to the characteristics of your data set. To do this in
+PyLoT, use the <img src=../icons/tune.png height=24 alt="Tune autopicks button" title="Tune autopicks button"> button to
+open the Tune Autopicker.
+
+<img src=images/gui/tuning/tune_autopicker.png>
+
+View of a station in the Tune Autopicker window.
+
+1. Select the event to be displayed and processed.
+2. Select the station from the event.
+3. To pick the currently displayed trace, click
+   the <img src=images/gui/tuning/autopick_trace_button.png alt="Pick trace button" title="Autopick trace button" height=16>
+   button.
+4. These tabs are used to select the current view. __Traces Plot__ contains a plot of the stations traces, where manual
+   picks can be created/edited. __Overview__ contains graphical results of the automatic picking process. The __P and S
+   tabs__ contain the automatic picking results of the P and S phase, while __log__ contains a useful text output of
+   automatic picking.
+5. These buttons are used to load/save/reset settings for automatic picking. The parameters can be saved in PyLoT input
+   files, which have the file ending *.in*. They are human readable text files, which can also be edited by hand. Saving
+   the parameters allows you to load them again later, even on different machines.
+6. These menus control the behaviour of the creation of manual picks from the Tune Autopicker window. Picks allows to
+   select the phase for which a manual pick should be created, Filter allows to filter waveforms and edit the filter
+   parameters. P-Channels and S-Channels allow to select the channels that should be displayed when creating a manual P
+   or S pick.
+7. This menu is the same as in the [Picking Window](#picking-window-settings), with the exception of the __Manual
+   Onsets__ options. The __Manual Onsets__ buttons accepts or reject the manual picks created in the Tune Autopicker
+   window, pressing accept adds them to the manual picks for the event, while reject removes them.
+8. The traces plot in the centre allows creating manual picks and viewing the waveforms.
+9. The parameters which influence the autopicking result are in the Main settings and Advanced settings tabs on the left
+   side. For a description of all the parameters see the [tuning documentation](tuning.md).
+
+### Production run of the autopicker
+
+After the settings used during tuning give the desired results, the autopicker can be used on the complete dataset. To
+invoke the autopicker on the whole set of events, click
+the <img src=../icons/autopylot_button.png alt="Autopick" title="Autopick" height=32> button.
+
+### Evaluation of automatic picks
+
+PyLoT has two internal consistency checks for automatic picks that were determined for an event:
+
+1. Jackknife check
+2. Wadati check
+
+#### 1. Jackknife check
+
+The jackknife test in PyLoT checks the consistency of automatically determined P-picks by checking the statistical
+variance of the picks. The variance of all P-picks is calculated and compared to the variance of subsets, in which one
+pick is removed.   
+The idea is, that picks that are close together in time should not influence the estimation of the variance much, while
+picks whose positions deviates from the norm influence the variance to a greater extent. If the estimated variance of a
+subset with a pick removed differs to much from the estimated variance of all picks, the pick that was removed from the
+subset will be marked as invalid.   
+The factor by which picks are allowed to skew from the estimation of variance can be configured, it is called *
+jackfactor*, see [here](tuning.md#Pick-quality-control).
+
+Additionally, the deviation of picks from the median is checked. For that, the median of all P-picks that passed the
+Jackknife test is calculated. Picks whose onset times deviate from the mean onset time by more than the *mdttolerance*
+are marked as invalid.
+
+<img src=images/gui/jackknife_plot.png title="Jackknife/Median test diagram">
+
+*The result of both tests (Jackknife and Median) is shown in a diagram afterwards. The onset time is plotted against a
+running number of stations. Picks that failed either the Jackknife or the median test are colored red. The median is
+plotted as a green line.*
+
+The Jackknife and median check are suitable to check for picks that are outside of the expected time window, for
+example, when a wrong phase was picked. It won't recognize picks that are in close proximity to the right onset which
+are just slightly to late/early.
+
+#### 2. Wadati check
+
+The Wadati check checks the consistency of S picks. For this the SP-time, the time difference between S and P onset is
+plotted against the P onset time. A line is fitted to the points, which minimizes the error. Then the deviation of
+single picks to this line is checked. If the deviation in seconds is above the *wdttolerance*
+parameter ([see here](tuning.md#Pick-quality-control)), the pick is marked as invalid.
+
+<img src=images/gui/wadati_plot.png title="Output diagram of Wadati check">
+
+*The Wadati plot in PyLoT shows the SP onset time difference over the P onset time. A first line is fitted (black). All
+picks which deviate to much from this line are marked invalid (red). Then a second line is fitted which excludes the
+invalid picks. From this lines slope, the ratio of P and S wave velocity is determined.*
+
+### Comparison between automatic and manual picks
+
+Every pick in PyLoT consists of an earliest possible, latest possible and most likely onset time. The earliest and
+latest possible onset time characterize the uncertainty of a pick. This approach is described in Diel, Kissling and
+Bormann (2012) - Tutorial for consistent phase picking at local to regional distances. These times are represented as a
+Probability Density Function (PDF) for every pick. The PDF is implemented as two exponential distributions around the
+most likely onset as the expected value.
+
+To compare two single picks, their PDFs are cross correlated to create a new PDF. This corresponds to the subtraction of
+the automatic pick from the manual pick.
+
+ <img src=images/gui/comparison/comparison_pdf.png title="Comparison between automatic and manual pick">
+
+*Comparison between an automatic and a manual pick for a station in PyLoT by comparing their PDFs.*  
+*The upper plot shows the difference between the two single picks that are shown in the lower plot.*
+*The difference is implemented as a cross correlation between the two PDFs. and results in a new PDF, the comparison
+PDF.*
+*The expected value of the comparison PDF corresponds to the time distance between the automatic and manual picks most
+likely onset.*
+*The standard deviation corresponds to the combined uncertainty.*
+
+To compare the automatic and manual picks between multiple stations of an event, the properties of all the comparison
+PDFs are shown in a histogram.
+
+<img src=images/gui/comparison/compare_widget.png title="Comparison between picks of an event">
+
+*Comparison between the automatic and manual picks for an event in PyLoT.*   
+*The top left plot shows the standard deviation of the comparison PDFs for P picks.*
+*The bottom left plot shows the expected values of the comparison PDFs for P picks.*
+*The top right plot shows the standard deviation of the comparison PDFs for S picks.*
+*The bottom right plot shows the expected values of the comparison PDFs for S picks.*   
+*The standard deviation plots show that most P picks have an uncertainty between 1 and 2 seconds, while S pick
+uncertainties have a much larger spread between 1 to 15 seconds.*
+*This means P picks have higher quality classes on average than S picks.*
+*The expected values are largely negative, meaning that the algorithm tends to pick earlier than the analyst with the
+applied settings (Manual - Automatic).*
+*The number of samples mentioned in the plots legends is the amount of stations that have an automatic and a manual P
+pick.*
+
+### Export and Import of automatic picks
+
+Picks can be saved in *.xml* format.
+
+# Location determination
+
+To be added.
+
+# FAQ
+
+Q: During manual picking the error "No channel to plot for phase ..." is displayed, and I am unable to create a pick.  
+A: Select a channel that should be used for the corresponding phase in the Pickwindow. For further information
+read [Picking Window settings](#picking-window-settings).
+
+Q: I see a warning "Mismatch in event identifiers" when loading picks from a file.  
+A: This means that PyLoT doesn't recognize the picks in the file as belonging to this specific event. They could have
+been saved under a different installation of PyLoT but with the same waveform data, which means they are still
+compatible and you can continue loading them or they could be the picks of a different event, in which case loading them
+is not recommended.

docs/tuning.md

@@ -0,0 +1,150 @@
+# AutoPyLoT Tuning
+
+A description of the parameters used for determining automatic picks.
+
+## Filter parameters and cut times
+
+Parameters applied to the traces before picking algorithm starts.
+
+| Name                | Description                                                                                                                                                                                                             |
+|---------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *P Start*, *P
+Stop* | Define time interval relative to trace start time for CF calculation on vertical trace. Value is relative to theoretical onset time if 'Use TauPy' option is enabled in main settings of 'Tune Autopicker' dialogue.    |
+| *S Start*, *S
+Stop* | Define time interval relative to trace start time for CF calculation on horizontal traces. Value is relative to theoretical onset time if 'Use TauPy' option is enabled in main settings of 'Tune Autopicker' dialogue. |
+| *Bandpass
+Z1*       | Filter settings for Butterworth bandpass applied to vertical trace for calculation of initial P pick.                                                                                                                   |
+| *Bandpass
+Z2*       | Filter settings for Butterworth bandpass applied to vertical trace for calculation of precise P pick.                                                                                                                   |
+| *Bandpass
+H1*       | Filter settings for Butterworth bandpass applied to horizontal traces for calculation of initial S pick.                                                                                                                |
+| *Bandpass
+H2*       | Filter settings for Butterworth bandpass applied to horizontal traces for calculation of precise S pick.                                                                                                                |
+
+## Inital P pick
+
+Parameters used for determination of initial P pick.
+
+| Name         | Description                                                                                                                  |
+|--------------|------------------------------------------------------------------------------------------------------------------------------|
+| *
+tLTA*       | Size of gliding LTA window in seconds used for calculation of HOS-CF.                                                        |
+| *pickwin
+P*  | Size of time window in seconds in which the minimum of the AIC-CF in front of the maximum of the HOS-CF is determined.       |
+| *
+AICtsmooth* | Average of samples in this time window will be used for smoothing of the AIC-CF.                                             |
+| *
+checkwinP*  | Time in front of the global maximum of the HOS-CF in which to search for a second local extrema.                             |
+| *minfactorP* | Used with *
+checkwinP*. If a second local maximum is found, it has to be at least as big as the first maximum * *minfactorP*. |
+| *
+tsignal*    | Time window in seconds after the initial P pick used for determining signal amplitude.                                       |
+| *
+tnoise*     | Time window in seconds in front of initial P pick used for determining noise amplitude.                                      |
+| *tsafetey*   | Time in seconds between *tsignal* and *
+tnoise*.                                                                              |
+| *
+tslope*     | Time window in seconds after initial P pick in which the slope of the onset is calculated.                                   |
+
+## Inital S pick
+
+Parameters used for determination of initial S pick
+
+| Name          | Description                                                                                                                  |
+|---------------|------------------------------------------------------------------------------------------------------------------------------|
+| *
+tdet1h*      | Length of time window in seconds in which AR params of the waveform are determined.                                          |
+| *
+tpred1h*     | Length of time window in seconds in which the waveform is predicted using the AR model.                                      |
+| *
+AICtsmoothS* | Average of samples in this time window is used for smoothing the AIC-CF.                                                     |
+| *
+pickwinS*    | Time window in which the minimum in the AIC-CF in front of the maximum in the ARH-CF is determined.                          |
+| *
+checkwinS*   | Time in front of the global maximum of the ARH-CF in which to search for a second local extrema.                             |
+| *minfactorP*  | Used with *
+checkwinS*. If a second local maximum is found, it has to be at least as big as the first maximum * *minfactorS*. |
+| *
+tsignal*     | Time window in seconds after the initial P pick used for determining signal amplitude.                                       |
+| *
+tnoise*      | Time window in seconds in front of initial P pick used for determining noise amplitude.                                      |
+| *tsafetey*    | Time in seconds between *tsignal* and *
+tnoise*.                                                                              |
+| *
+tslope*      | Time window in seconds after initial P pick in which the slope of the onset is calculated.                                   |
+
+## Precise P pick
+
+Parameters used for determination of precise P pick.
+
+| Name         | Description                                                                                                                                                                                                             |
+|--------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *Precalcwin* | Time window in seconds for recalculation of the HOS-CF. The new CF will be two times the size of *
+Precalcwin*, since it will be calculated from the initial pick to +/- *Precalcwin*.                                   |
+| *
+tsmoothP*   | Average of samples in this time window will be used for smoothing the second HOS-CF.                                                                                                                                    |
+| *
+ausP*       | Controls artificial uplift of samples during precise picking. A common local minimum of the smoothed and unsmoothed HOS-CF is found when the previous sample is larger or equal to the current sample times (1+*
+ausP*). |
+
+## Precise S pick
+
+Parameters used for determination of precise S pick.
+
+| Name         | Description                                                                                                                                                                                                             |
+|--------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *
+tdet2h*     | Time window for determination of AR coefficients.                                                                                                                                                                       |
+| *
+tpred2h*    | Time window in which the waveform is predicted using the determined AR parameters.                                                                                                                                      |
+| *Srecalcwin* | Time window for recalculation of ARH-CF. New CF will be calculated from initial pick +/- *
+Srecalcwin*.                                                                                                                  |
+| *
+tsmoothS*   | Average of samples in this time window will be used for smoothing the second ARH-CF.                                                                                                                                    |
+| *
+ausS*       | Controls artificial uplift of samples during precise picking. A common local minimum of the smoothed and unsmoothed ARH-CF is found when the previous sample is larger or equal to the current sample times (1+*
+ausS*). |
+| *
+pickwinS*   | Time window around initial pick in which to look for a precise pick.                                                                                                                                                    |
+
+## Pick quality control
+
+Parameters used for checking quality and integrity of automatic picks.
+
+| Name                                       | Description                                                                                                                                                                                                                                                                    |
+|--------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *
+minAICPslope*                             | Initial P picks with a slope lower than this value will be discared.                                                                                                                                                                                                           |
+| *
+minAICPSNR*                               | Initial P picks with a SNR below this value will be discarded.                                                                                                                                                                                                                 |
+| *
+minAICSslope*                             | Initial S picks with a slope lower than this value will be discarded.                                                                                                                                                                                                          |
+| *
+minAICSSNR*                               | Initial S picks with a SNR below this value will be discarded.                                                                                                                                                                                                                 |
+| *minsiglength*, *noisefacor*. *minpercent* | Parameters for checking signal length. In the time window of size *
+minsiglength* after the initial P pick *
+minpercent* of samples have to be larger than the RMS value.                                                                                                        |
+| *
+zfac*                                     | To recognize misattributed S picks, the RMS amplitude of vertical and horizontal traces are compared. The RMS amplitude of the vertical traces has to be at least *
+zfac* higher than the RMS amplitude on the horizontal traces for the pick to be accepted as a valid P pick. |
+| *
+jackfactor*                               | A P pick is removed if the jackknife pseudo value of the variance of his subgroup is larger than the variance of all picks multiplied with the *
+jackfactor*.                                                                                                                   |
+| *
+mdttolerance*                             | Maximum allowed deviation of P onset times from the median. Value in seconds.                                                                                                                                                                                                  |
+| *
+wdttolerance*                             | Maximum allowed deviation of S onset times from the line during the Wadati test. Value in seconds.                                                                                                                                                                             |
+
+## Pick quality determination
+
+Parameters for discrete quality classes.
+
+| Name             | Description                                                                                                                                                                                                           |
+|------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| *
+timeerrorsP*    | Width of the time windows in seconds between earliest and latest possible pick which represent the quality classes 0, 1, 2, 3 for P onsets.                                                                           |
+| *
+timeerrorsS*    | Width of the time windows in seconds between earliest and latest possible pick which represent the quality classes 0, 1, 2, 3 for S onsets.                                                                           |
+| *nfacP*, *nfacS* | For determination of latest possible onset time. The time when the signal reaches an amplitude of *
+nfac* * mean value of the RMS amplitude in the time window *tnoise* corresponds to the latest possible onset time. |
+

help/index.html

@@ -0,0 +1,19 @@
+<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>
+<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>
+</ul>
+<p>Read more on the
+    <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>

icons.qrc

@@ -0,0 +1,62 @@
+<RCC>
+    <qresource>
+        <file>icons/pylot.ico</file>
+        <file>icons/pylot.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/pick_qualities_button.png</file>
+        <file>icons/eventlist_xml_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/key_A.png</file>
+        <file>icons/key_E.png</file>
+        <file>icons/key_N.png</file>
+        <file>icons/key_P.png</file>
+        <file>icons/key_Q.png</file>
+        <file>icons/key_R.png</file>
+        <file>icons/key_S.png</file>
+        <file>icons/key_T.png</file>
+        <file>icons/key_U.png</file>
+        <file>icons/key_V.png</file>
+        <file>icons/key_W.png</file>
+        <file>icons/key_Z.png</file>
+        <file>icons/filter.png</file>
+        <file>icons/filter_p.png</file>
+        <file>icons/filter_s.png</file>
+        <file>icons/sync.png</file>
+        <file>icons/zoom_0.png</file>
+        <file>icons/zoom_in.png</file>
+        <file>icons/zoom_out.png</file>
+        <file>splash/splash.png</file>
+    </qresource>
+    <qresource prefix="/help">
+        <file>help/index.html</file>
+    </qresource>
+</RCC>

inputs/PILOT_TimeErrors.in

@@ -0,0 +1,3 @@
+## default time errors for old PILOT phases
+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

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#
+/DATA/Insheim                                      #rootpath#       %project path                                                                                        
+EVENT_DATA/LOCAL                                   #datapath#       %data path                                                                                           
+2018.02_Insheim                                    #database#       %name of data base                                                                                   
+e0006.038.18                                       #eventID#        %event ID for single event processing (* for all events found in database)                           
+/DATA/Insheim/STAT_INFO                            #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#
+/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                                                       
+Insheim_min1d032016_auto.in                        #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!
+0.0 0.0                                            #magscaling#     %Scaling relation for derived local magnitude [a*Ml+b].                            If zeros are set, no scaling of network magnitude is applied!
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+#filter settings#
+2.0 2.0                                            #minfreq#        %Lower filter frequency [P, S]                                                                       
+30.0 15.0                                          #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#
+local                                              #extent#         %extent of array ("local", "regional" or "global")                                                   
+7.0                                                #pstart#         %start time [s] for calculating CF for P-picking                                                     
+16.0                                               #pstop#          %end time [s] for calculating CF for P-picking                                                       
+-0.5                                               #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                                         
+False                                              #use_taup#       %use estimated traveltimes from TauPy for calculating windows for CF                                 
+iasp91                                             #taup_model#     %define TauPy model for traveltime estimation                                                        
+2.0 20.0                                           #bpz1#           %lower/upper corner freq. of first band pass filter Z-comp. [Hz]                                     
+2.0 30.0                                           #bpz2#           %lower/upper corner freq. of second band pass filter Z-comp. [Hz]                                    
+2.0 10.0                                           #bph1#           %lower/upper corner freq. of first band pass filter H-comp. [Hz]                                     
+2.0 15.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)                                       
+4.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.0 1.0 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.4                                                #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.4                                                #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.2 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.04 0.08 0.16 0.32                                #timeerrorsP#    %discrete time errors [s] corresponding to picking weights [0 1 2 3] for P                           
+0.05 0.10 0.20 0.40                                #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.1                                                #noisefactor#    %noiselevel*noisefactor=threshold                                                                    
+50.0                                               #minpercent#     %required percentage of amplitudes exceeding threshold                                               
+1.1                                                #zfac#           %P-amplitude must exceed at least zfac times RMS-S amplitude                                         
+5.0                                                #mdttolerance#   %maximum allowed deviation of P picks from median [s]                                                
+1.0                                                #wdttolerance#   %maximum allowed deviation from Wadati-diagram                                                       
+2.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

inputs/richter_scaling.data

@@ -0,0 +1,53 @@
+ 0 1.4
+ 10 1.5
+ 20 1.7
+ 25 1.9
+ 30 2.1
+ 35 2.3
+ 40 2.4
+ 45 2.5
+ 50 2.6
+ 60 2.8
+ 70 2.8
+ 75 2.9
+ 85 2.9
+ 90 3.0
+100 3.0
+110 3.1
+120 3.1
+130 3.2
+140 3.2
+150 3.3
+160 3.3
+170 3.4
+180 3.4
+190 3.5
+200 3.5
+210 3.6
+230 3.7
+240 3.7
+250 3.8
+260 3.8
+270 3.9
+280 3.9
+290 4.0
+300 4.0
+310 4.1
+320 4.2
+330 4.2
+340 4.2
+350 4.3
+360 4.3
+370 4.3
+380 4.4
+390 4.4
+400 4.5
+430 4.6
+470 4.7
+510 4.8
+560 4.9
+600 5.1
+700 5.2
+800 5.4
+900 5.5
+1000 5.7

makePyLoT.py

@@ -0,0 +1,228 @@
+#!/usr/bin/env python
+# encoding: utf-8
+from __future__ import print_function
+
+"""
+makePyLoT -- build and install PyLoT
+
+makePyLoT is a python make file in order to establish the folder structure and
+meet requisites
+
+It defines
+:class CLIError:
+:method main:
+
+:author:     Sebastian Wehling-Benatelli
+
+:copyright:  2014 MAGS2 EP3 Working Group. All rights reserved.
+
+:license:    GNU Lesser General Public License, Version 3
+    (http://www.gnu.org/copyleft/lesser.html)
+
+:contact:    sebastian.wehling@rub.de
+
+updated: Updated
+"""
+
+import glob
+import os
+import sys
+import shutil
+import copy
+
+from argparse import ArgumentParser
+from argparse import RawDescriptionHelpFormatter
+
+__all__ = []
+__version__ = 0.1
+__date__ = '2014-11-26'
+__updated__ = '2016-04-28'
+
+DEBUG = 0
+TESTRUN = 0
+PROFILE = 0
+
+
+class CLIError(Exception):
+    """Generic exception to raise and log different fatal errors."""
+
+    def __init__(self, msg):
+        super(CLIError).__init__(type(self))
+        self.msg = "E: %s" % msg
+
+    def __str__(self):
+        return self.msg
+
+    def __unicode__(self):
+        return self.msg
+
+
+def main(argv=None):  # IGNORE:C0111
+    '''Command line options.'''
+
+    if argv is None:
+        argv = sys.argv
+    else:
+        sys.argv.extend(argv)
+
+    program_name = os.path.basename(sys.argv[0])
+    program_version = "v%s" % __version__
+    program_build_date = str(__updated__)
+    program_version_message = 'makePyLoT %s (%s)' % (
+        program_version, program_build_date)
+    program_shortdesc = __import__('__main__').__doc__.split("\n")[1]
+    program_license = '''{0:s}
+
+    Created by Sebastian Wehling-Benatelli on {1:s}.
+    Copyright 2014 MAGS2 EP3 Working Group. All rights reserved.
+
+    GNU Lesser General Public License, Version 3
+    (http://www.gnu.org/copyleft/lesser.html)
+
+    Distributed on an "AS IS" basis without warranties
+    or conditions of any kind, either express or implied.
+
+    USAGE
+    '''.format(program_shortdesc, str(__date__))
+
+    try:
+        # Setup argument parser
+        parser = ArgumentParser(description=program_license,
+                                formatter_class=RawDescriptionHelpFormatter)
+        parser.add_argument("-b", "--build", dest="build", action="store_true",
+                            help="build PyLoT")
+        parser.add_argument("-v", "--verbose", dest="verbose", action="count",
+                            help="set verbosity level")
+        parser.add_argument("-i", "--install", dest="install",
+                            action="store_true",
+                            help="install PyLoT on the system")
+        parser.add_argument("-d", "--directory", dest="directory",
+                            help="installation directory", metavar="RE")
+        parser.add_argument('-V', '--version', action='version',
+                            version=program_version_message)
+
+        # Process arguments
+        args = parser.parse_args()
+
+        verbose = args.verbose
+        build = args.build
+        install = args.install
+        directory = args.directory
+
+        if verbose > 0:
+            print("Verbose mode on")
+        if install and not directory:
+            raise CLIError("""Trying to install without appropriate
+                           destination; please specify an installation
+                           directory!""")
+        if build and install:
+            print("Building and installing PyLoT ...\n")
+            buildPyLoT(verbose)
+            installPyLoT(verbose)
+        elif build and not install:
+            print("Building PyLoT without installing! Please wait ...\n")
+            buildPyLoT(verbose)
+        cleanUp()
+        return 0
+    except KeyboardInterrupt:
+        cleanUp(1)
+        return 0
+    except Exception as e:
+        if DEBUG or TESTRUN:
+            raise e
+        indent = len(program_name) * " "
+        sys.stderr.write(program_name + ": " + repr(e) + "\n")
+        sys.stderr.write(indent + "  for help use --help")
+        return 2
+
+
+def buildPyLoT(verbosity=None):
+    system = sys.platform
+    if verbosity > 1:
+        msg = ("... on system: {0}\n"
+               "\n"
+               "              Current working directory: {1}\n"
+               ).format(system, os.getcwd())
+        print(msg)
+    if system.startswith(('win', 'microsoft')):
+        raise CLIError(
+            "building on Windows system not tested yet; implementation pending")
+    elif system == 'darwin':
+        # create a symbolic link to the desired python interpreter in order to
+        # display the right application name
+        for path in os.getenv('PATH').split(':'):
+            found = glob.glob(os.path.join(path, 'python'))
+            if found:
+                os.symlink(found, './PyLoT')
+                break
+
+
+def installPyLoT(verbosity=None):
+    files_to_copy = {'pylot_local.in': ['~', '.pylot'],
+                     'pylot_regional.in': ['~', '.pylot'],
+                     'pylot_global.in': ['~', '.pylot']}
+    if verbosity > 0:
+        print('starting installation of PyLoT ...')
+    if verbosity > 1:
+        print('copying input files into destination folder ...')
+    ans = input('please specify scope of interest '
+                '([0]=local, 1=regional, 2=global, 3=active) :') or 0
+    if not isinstance(ans, int):
+        ans = int(ans)
+    if ans == 0:
+        ans = 'local'
+    elif ans == 1:
+        ans = 'regional'
+    elif ans == 2:
+        ans = 'global'
+    elif ans == 3:
+        ans = 'active'
+    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('pylot.in')
+            link_dest = os.path.join(*link_dest)
+        destination.append(file)
+        destination = os.path.join(*destination)
+        srcfile = os.path.join('input', file)
+        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))
+        shutil.copyfile(srcfile, destination)
+        if link_file:
+            if verbosity:
+                print('linking input file for autoPyLoT ...')
+            os.symlink(destination, link_dest)
+
+
+def cleanUp(verbosity=None):
+    if verbosity >= 1:
+        print('cleaning up build files...')
+    if sys.platform == 'darwin':
+        os.remove('./PyLoT')
+
+
+if __name__ == "__main__":
+    if DEBUG:
+        sys.argv.append("-h")
+        sys.argv.append("-v")
+    if TESTRUN:
+        import doctest
+
+        doctest.testmod()
+    if PROFILE:
+        import cProfile
+        import pstats
+
+        profile_filename = 'makePyLoT_profile.txt'
+        cProfile.run('main()', profile_filename)
+        statsfile = open("profile_stats.txt", "wb")
+        p = pstats.Stats(profile_filename, stream=statsfile)
+        stats = p.strip_dirs().sort_stats('cumulative')
+        stats.print_stats()
+        statsfile.close()
+        sys.exit(0)
+    sys.exit(main())

pylot.yml

@@ -0,0 +1,14 @@
+name: pylot_38
+channels:
+  - conda-forge
+  - defaults
+dependencies:
+  - cartopy=0.20.2
+  - matplotlib-base=3.3.4
+  - numpy=1.22.3
+  - obspy=1.3.0
+  - pyqtgraph=0.12.4
+  - pyside2>=5.13.2
+  - python=3.8.12
+  - qt>=5.12.9
+  - scipy=1.8.0

pylot/__init__.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+# --------------------------------------------------------
+# Purpose: Convience imports for PyLoT
+#
+'''
+================================================
+PyLoT - the Python picking and Localization Tool
+================================================
+
+This python library contains a graphical user interfaces for picking
+seismic phases. This software needs ObsPy (http://github.com/obspy/obspy/wiki)
+and the Qt4 libraries to be installed first.
+
+PILOT has been developed in Mathworks' MatLab. In order to distribute
+PILOT without facing portability problems, it has been decided to re-
+develop 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.
+
+:copyright:
+    The PyLoT Development Team
+:license:
+    GNU Lesser General Public License, Version 3
+    (http://www.gnu.org/copyleft/lesser.html)
+'''

pylot/core/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

pylot/core/analysis/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

pylot/core/analysis/magnitude.py

@@ -0,0 +1,871 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""
+Created autumn/winter 2015.
+Revised/extended summer 2017.
+
+:author: Ludger Küperkoch / MAGS2 EP3 working group
+"""
+
+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
+
+
+def richter_magnitude_scaling(delta):
+    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(distance, richter_scaling)
+    return func(delta, params)
+
+
+class Magnitude(object):
+    """
+    Base class object for Magnitude calculation within PyLoT.
+    """
+
+    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._magnitudes = dict()
+
+    def __str__(self):
+        print(
+            'number of stations used: {0}\n'.format(len(self.magnitudes.values())))
+        print('\tstation\tmagnitude')
+        for s, m in self.magnitudes.items(): print('\t{0}\t{1}'.format(s, m))
+
+    def __nonzero__(self):
+        return bool(self.magnitudes)
+
+    @property
+    def type(self):
+        return self._type
+
+    @property
+    def plot_flag(self):
+        return self._plot_flag
+
+    @plot_flag.setter
+    def plot_flag(self, value):
+        self._plot_flag = value
+
+    @property
+    def verbose(self):
+        return self._verbosity
+
+    @verbose.setter
+    def verbose(self, value):
+        if not isinstance(value, bool):
+            print('WARNING: only boolean values accepted...\n')
+            value = bool(value)
+        self._verbosity = value
+
+    @property
+    def stream(self):
+        return self._stream
+
+    @stream.setter
+    def stream(self, value):
+        self._stream = value
+
+    @property
+    def event(self):
+        return self._event
+
+    @property
+    def origin_id(self):
+        return self._event.origins[0].resource_id
+
+    @property
+    def arrivals(self):
+        return self._event.origins[0].arrivals
+
+    @property
+    def magnitudes(self):
+        return self._magnitudes
+
+    @magnitudes.setter
+    def magnitudes(self, value):
+        """
+        takes a tuple and saves the key value pair to private
+        attribute _magnitudes
+        :param value: station, magnitude value pair
+        :type value: tuple or list
+        :return:
+        """
+        station, magnitude = value
+        self._magnitudes[station] = magnitude
+
+    def calc(self):
+        pass
+
+    def updated_event(self, magscaling=None):
+        net_ml = self.net_magnitude(magscaling)
+        if net_ml:
+            self.event.magnitudes.append(net_ml)
+        return self.event
+
+    def net_magnitude(self, magscaling=None):
+        if self:
+            if magscaling is None:
+                scaling = False
+            elif magscaling[0] == 0.0 and magscaling[1] == 0.0:
+                scaling = False
+            else:
+                scaling = True
+            if scaling == True:
+                # 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 scaling necessary
+                # Temporary fix needs rework
+                if (len(self.magnitudes.keys()) == 0):
+                    print("Error in local magnitude calculation ")
+                    return None
+                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
+
+
+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!
+    """
+
+    # poles, zeros and sensitivity of WA seismograph
+    # (see Uhrhammer & Collins, 1990, BSSA, pp. 702-716)
+    _paz = {
+        'poles': [5.6089 - 5.4978j, -5.6089 - 5.4978j],
+        'zeros': [0j, 0j],
+        'gain': 2080,
+        'sensitivity': 1
+    }
+
+    _amplitudes = dict()
+
+    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()
+
+    @property
+    def calc_win(self):
+        return self._calc_win
+
+    @calc_win.setter
+    def calc_win(self, value):
+        self._calc_win = value
+
+    @property
+    def wascaling(self):
+        return self._wascaling
+
+    @property
+    def amplitudes(self):
+        return self._amplitudes
+
+    @amplitudes.setter
+    def amplitudes(self, value):
+        station, a0 = value
+        self._amplitudes[station] = a0
+
+    def peak_to_peak(self, st, t0):
+
+        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)
+
+        # trim waveform to common range
+        stime, etime = common_range(st)
+        st.trim(stime, etime)
+
+        # get time delta from waveform data
+        dt = st[0].stats.delta
+
+        power = [np.power(tr.data, 2) for tr in st if tr.stats.channel[-1] not
+                 in 'Z3']
+        # checking horizontal count and calculating power_sum accordingly
+        if len(power) == 1:
+            print('WARNING: Only one horizontal found for station {0}.'.format(st[0].stats.station))
+            power_sum = power[0]
+        elif len(power) == 2:
+            power_sum = power[0] + power[1]
+        else:
+            raise ValueError('Wood-Anderson aomplitude defintion only valid for'
+                             ' up to two horizontals: {0} given'.format(len(power)))
+
+        sqH = np.sqrt(power_sum)
+
+        # get time array
+        th = np.arange(0, st[0].stats.npts / st[0].stats.sampling_rate, 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 for station {0}: {1} "
+                  "mm".format(st[0].stats.station, wapp))
+
+        # check for plot flag (for debugging only)
+        fig = None
+        if iplot > 1:
+            fig = plt.figure()
+            ax = fig.add_subplot(211)
+            ax.plot(th, st[0].data, 'k')
+            ax.plot(th, sqH)
+            ax.plot(th[iwin], sqH[iwin], 'g')
+            ax.plot([t0 - stime, t0 - stime], [0, max(sqH)], 'r', linewidth=2)
+            ax.set_title('Station %s, Channel %s, RMS Horizontal Trace, '
+                         'WA-peak-to-peak=%6.3f mm' % (st[0].stats.station,
+                                                       st[0].stats.channel,
+                                                       wapp))
+            ax.set_xlabel('Time [s]')
+            ax.set_ylabel('Displacement [mm]')
+            ax = fig.add_subplot(212)
+            ax.plot(th, st[1].data, 'k')
+            ax.plot(th, sqH)
+            ax.plot(th[iwin], sqH[iwin], 'g')
+            ax.plot([t0 - stime, t0 - stime], [0, max(sqH)], 'r', linewidth=2)
+            ax.set_title('Channel %s, RMS Horizontal Trace, '
+                         'WA-peak-to-peak=%6.3f mm' % (st[1].stats.channel,
+                                                       wapp))
+            ax.set_xlabel('Time [s]')
+            ax.set_ylabel('Displacement [mm]')
+            fig.show()
+            try:
+                input()
+            except SyntaxError:
+                pass
+            plt.close(fig)
+
+        return wapp, fig
+
+    def calc(self):
+        for a in self.arrivals:
+            if a.phase not in 'sS':
+                continue
+            pick = a.pick_id.get_referred_object()
+            station = pick.waveform_id.station_code
+            # make sure calculating Ml only from reliable onsets
+            # NLLoc: time_weight = 0 => do not use onset!
+            if a.time_weight == 0:
+                print("Uncertain pick at Station {}, do not use it!".format(station))
+                continue
+            wf = select_for_phase(self.stream.select(
+                station=station), a.phase)
+            if not wf:
+                if self.verbose:
+                    print(
+                        'WARNING: no waveform data found for station {0}'.format(
+                            station))
+                continue
+            delta = degrees2kilometers(a.distance)
+            onset = pick.time
+            a0, self.p2p_fig = self.peak_to_peak(wf, onset)
+            amplitude = ope.Amplitude(generic_amplitude=a0 * 1e-3)
+            amplitude.unit = 'm'
+            amplitude.category = 'point'
+            amplitude.waveform_id = pick.waveform_id
+            amplitude.magnitude_hint = self.type
+            amplitude.pick_id = pick.resource_id
+            amplitude.type = 'AML'
+            self.event.amplitudes.append(amplitude)
+            self.amplitudes = (station, amplitude)
+            # using standard Gutenberg-Richter relation
+            # 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])
+            if self.verbose:
+                print(
+                    "Local Magnitude for station {0}: ML = {1:3.1f}".format(
+                        station, magnitude.mag))
+            magnitude.origin_id = self.origin_id
+            magnitude.waveform_id = pick.waveform_id
+            magnitude.amplitude_id = amplitude.resource_id
+            magnitude.station_magnitude_type = self.type
+            self.event.station_magnitudes.append(magnitude)
+            self.magnitudes = (station, magnitude)
+
+
+class MomentMagnitude(Magnitude):
+    '''
+    Method to calculate seismic moment Mo and moment magnitude Mw.
+    Requires results of class calcsourcespec for calculating plateau w0
+    and corner frequency fc of source spectrum, respectively. Uses
+    subfunction calcMoMw.py. Returns modified dictionary of picks including
+    Dc-value, corner frequency fc, seismic moment Mo and
+    corresponding moment magntiude Mw.
+    '''
+
+    _props = dict()
+
+    def __init__(self, stream, event, vp, Qp, density, verbosity=False,
+                 iplot=False):
+        super(MomentMagnitude, self).__init__(stream, event, verbosity, iplot)
+
+        self._vp = vp
+        self._Qp = Qp
+        self._density = density
+        self._type = 'Mw'
+        self.calc()
+
+    @property
+    def p_velocity(self):
+        return self._vp
+
+    @property
+    def p_attenuation(self):
+        return self._Qp
+
+    @property
+    def rock_density(self):
+        return self._density
+
+    @property
+    def moment_props(self):
+        return self._props
+
+    @moment_props.setter
+    def moment_props(self, value):
+        station, props = value
+        self._props[station] = props
+
+    @property
+    def seismic_moment(self):
+        return self._m0
+
+    @seismic_moment.setter
+    def seismic_moment(self, value):
+        self._m0 = value
+
+    def calc(self):
+        for a in self.arrivals:
+            if a.phase not in 'pP':
+                continue
+            # make sure calculating Mo only from reliable onsets
+            # NLLoc: time_weight = 0 => do not use onset!
+            if a.time_weight == 0:
+                continue
+            pick = a.pick_id.get_referred_object()
+            station = pick.waveform_id.station_code
+            if len(self.stream) <= 2:
+                print("Station:" '{0}'.format(station))
+                print("WARNING: No instrument corrected data available,"
+                      " no magnitude calculation possible! Go on.")
+                continue
+            wf = self.stream.select(station=station)
+            if not wf:
+                continue
+            try:
+                scopy = wf.copy()
+            except AssertionError:
+                print("WARNING: Something's wrong with the data,"
+                      "station {},"
+                      "no calculation of moment magnitude possible! Go on.".format(station))
+                continue
+            onset = pick.time
+            distance = degrees2kilometers(a.distance)
+            azimuth = a.azimuth
+            incidence = a.takeoff_angle
+            if not 0. <= incidence <= 360.:
+                if self.verbose:
+                    print(f'WARNING: Incidence angle outside bounds - {incidence}')
+                return
+            w0, fc = calcsourcespec(scopy, onset, self.p_velocity, distance,
+                                    azimuth, incidence, self.p_attenuation,
+                                    self.plot_flag, self.verbose)
+            if w0 is None or fc is None:
+                if self.verbose:
+                    print("WARNING: insufficient frequency information")
+                continue
+            WF = select_for_phase(scopy, "P")
+            m0, mw = calcMoMw(WF, w0, self.rock_density, self.p_velocity,
+                              distance, self.verbose)
+            self.moment_props = (station, dict(w0=w0, fc=fc, Mo=m0))
+            magnitude = ope.StationMagnitude(mag=mw)
+            magnitude.origin_id = self.origin_id
+            magnitude.waveform_id = pick.waveform_id
+            magnitude.station_magnitude_type = self.type
+            self.event.station_magnitudes.append(magnitude)
+            self.magnitudes = (station, magnitude)
+
+    # WIP JG
+    def getSourceSpec(self):
+        for a in self.arrivals:
+            if a.phase not in 'pP':
+                continue
+            # make sure calculating Mo only from reliable onsets
+            # NLLoc: time_weight = 0 => do not use onset!
+            if a.time_weight == 0:
+                continue
+            pick = a.pick_id.get_referred_object()
+            station = pick.waveform_id.station_code
+            if len(self.stream) <= 2:
+                print("Station:" '{0}'.format(station))
+                print("WARNING: No instrument corrected data available,"
+                      " no magnitude calculation possible! Go on.")
+                continue
+            wf = self.stream.select(station=station)
+            if not wf:
+                continue
+            try:
+                scopy = wf.copy()
+            except AssertionError:
+                print("WARNING: Something's wrong with the data,"
+                      "station {},"
+                      "no calculation of moment magnitude possible! Go on.".format(station))
+                continue
+            onset = pick.time
+            distance = degrees2kilometers(a.distance)
+            azimuth = a.azimuth
+            incidence = a.takeoff_angle
+            w0, fc, plt = calcsourcespec(scopy, onset, self.p_velocity, distance,
+                                    azimuth, incidence, self.p_attenuation,
+                                    3, self.verbose)
+            return w0, fc, plt
+
+def calcMoMw(wfstream, w0, rho, vp, delta, verbosity=False):
+    '''
+    Subfunction of run_calcMoMw to calculate individual
+    seismic moments and corresponding moment magnitudes.
+
+    :param: wfstream
+    :type:  `~obspy.core.stream.Stream`
+
+    :param: w0, height of plateau of source spectrum
+    :type:  float
+
+    :param: rho, rock density [kg/m³]
+    :type:  integer
+
+    :param: delta, hypocentral distance [km]
+    :type:  integer
+
+    :param: inv, name/path of inventory or dataless-SEED file
+    :type:  string
+    '''
+
+    tr = wfstream[0]
+    delta = delta * 1000  # hypocentral distance in [m]
+
+    if verbosity:
+        print(
+            "calcMoMw: Calculating seismic moment Mo and moment magnitude Mw \
+                for station {0} ...".format(tr.stats.station))
+
+    # additional common parameters for calculating Mo
+    # average radiation pattern of P waves (Aki & Richards, 1980)
+    rP = 2 / np.sqrt(15)
+    freesurf = 2.0  # free surface correction, assuming vertical incidence
+
+    Mo = w0 * 4 * np.pi * rho * np.power(vp, 3) * delta / (rP * freesurf)
+
+    # Mw = np.log10(Mo * 1e07) * 2 / 3 - 10.7 # after Hanks & Kanamori (1979),
+    # defined for [dyn*cm]!
+    Mw = np.log10(Mo) * 2 / 3 - 6.7  # for metric units
+
+    if verbosity:
+        print(
+            "calcMoMw: Calculated seismic moment Mo = {0} Nm => Mw = {1:3.1f} ".format(
+                Mo, Mw))
+
+    return Mo, Mw
+
+
+def calcsourcespec(wfstream, onset, vp, delta, azimuth, incidence,
+                   qp, iplot=0, verbosity=False):
+    '''
+    Subfunction to calculate the source spectrum and to derive from that the plateau
+    (usually called omega0) and the corner frequency assuming Aki's omega-square
+    source model. Has to be derived from instrument corrected displacement traces,
+    thus restitution and integration necessary! Integrated traces are rotated
+    into ray-coordinate system ZNE => LQT using Obspy's rotate modul!
+
+    :param: wfstream (corrected for instrument)
+    :type:  `~obspy.core.stream.Stream`
+
+    :param: onset, P-phase onset time
+    :type: float
+
+    :param: vp, Vp-wave velocity
+    :type:  float
+
+    :param: delta, hypocentral distance [km]
+    :type:  integer
+
+    :param: azimuth
+    :type:  integer
+
+    :param: incidence
+    :type:  integer
+
+    :param: Qp, quality factor for P-waves
+    :type:  integer
+
+    :param: iplot, show results (iplot>1) or not (iplot<1)
+    :type:  integer
+    '''
+    if verbosity:
+        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
+
+    dist = delta * 1000  # hypocentral distance in [m]
+
+    Fc = None
+    w0 = None
+    zdat = select_for_phase(wfstream, "P")
+
+    if len(zdat) == 0:
+        print("No vertical component found in stream:\n{}".format(wfstream))
+        print("No calculation of source spectrum possible!")
+        return w0, Fc
+
+    dt = zdat[0].stats.delta
+
+    freq = zdat[0].stats.sampling_rate
+
+    # trim traces to common range (for rotation)
+    trstart, trend = common_range(wfstream)
+    wfstream.trim(trstart, trend)
+    # rotate into LQT (ray-coordindate-) system using Obspy's rotate
+    # L: P-wave direction
+    # Q: SV-wave direction
+    # T: SH-wave direction
+    LQT = wfstream.rotate('ZNE->LQT', azimuth, incidence)
+    ldat = LQT.select(component="L")
+    if len(ldat) == 0:
+        # if horizontal channels are 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!")
+        # 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))
+
+    # get window after P pulse for
+    # calculating source spectrum
+    rel_onset = onset - trstart
+    impickP = int(rel_onset * freq)
+    wfzc = Ldat[impickP: len(Ldat) - 1]
+    # get time array
+    t = np.arange(0, len(inttrz) * dt, dt)
+    # calculate spectrum using only first cycles of
+    # waveform after P onset!
+    zc = crossings_nonzero_all(wfzc)
+    if np.size(zc) == 0 or len(zc) <= 3:
+        if verbosity:
+            print("calcsourcespec: Something is wrong with the waveform, "
+                  "no zero crossings derived!\n")
+            print("No calculation of source spectrum possible!")
+    else:
+        index = min([3, len(zc) - 1])
+        calcwin = (zc[index] - zc[0]) * dt
+        iwin = getsignalwin(t, rel_onset, calcwin)
+        xdat = Ldat[iwin]
+
+        # fft
+        fny = freq / 2
+        # l = len(xdat) / freq
+        # number of fft bins after Bath
+        # n = freq * l
+        # find next power of 2 of data length
+        m = pow(2, np.ceil(np.log(len(xdat)) / np.log(2)))
+        N = min(int(np.power(m, 2)), 16384)
+        # N = int(np.power(m, 2))
+        y = dt * np.fft.fft(xdat, N)
+        Y = abs(y[: int(N / 2)])
+        L = (N - 1) / freq
+        f = np.arange(0, fny, 1 / L)
+
+        # remove zero-frequency and frequencies above
+        # corner frequency of seismometer (assumed
+        # to be 100 Hz)
+        fi = np.where((f >= 1) & (f < 100))
+        F = f[fi]
+        YY = Y[fi]
+
+        # correction for attenuation
+        wa = 2 * np.pi * F  # angular frequency
+        D = np.exp((wa * dist) / (2 * vp * Q * F ** A))
+        YYcor = YY.real * D
+
+        # get plateau (DC value) and corner frequency
+        # initial guess of plateau
+        w0in = np.mean(YYcor[0:100])
+        # initial guess of corner frequency
+        # where spectral level reached 50% of flat level
+        iin = np.where(YYcor >= 0.5 * w0in)
+        Fcin = F[iin[0][np.size(iin) - 1]]
+
+        # use of implicit scipy otimization function
+        fit = synthsourcespec(F, w0in, Fcin)
+        [optspecfit, _] = curve_fit(synthsourcespec, F, YYcor, [w0in, Fcin])
+        w01 = optspecfit[0]
+        fc1 = optspecfit[1]
+        if verbosity:
+            print("calcsourcespec: Determined w0-value: %e m/Hz, \n"
+                  "calcsourcespec: Determined corner frequency: %f Hz" % (w01, fc1))
+
+        # use of conventional fitting
+        [w02, fc2] = fitSourceModel(F, YYcor, Fcin, iplot, verbosity)
+
+        # get w0 and fc as median of both
+        # source spectrum fits
+        w0 = np.median([w01, w02])
+        Fc = np.median([fc1, fc2])
+        if verbosity:
+            print("calcsourcespec: Using w0-value = %e m/Hz and fc = %f Hz" % (
+                w0, Fc))
+    if iplot >= 1:
+        f1 = plt.figure()
+        tLdat = np.arange(0, len(Ldat) * dt, dt)
+        plt.subplot(2, 1, 1)
+        # show displacement in mm
+        p1, = plt.plot(t, np.multiply(inttrz, 1000), 'k')
+        p2, = plt.plot(tLdat, np.multiply(Ldat, 1000))
+        plt.legend([p1, p2], ['Displacement', 'Rotated Displacement'])
+        if iplot == 1:
+            plt.plot(t[iwin], np.multiply(xdat, 1000), 'g')
+            plt.title('Seismogram and P Pulse, Station %s-%s' \
+                      % (zdat[0].stats.station, zdat[0].stats.channel))
+        else:
+            plt.title('Seismogram, Station %s-%s' \
+                      % (zdat[0].stats.station, zdat[0].stats.channel))
+        plt.xlabel('Time since %s' % zdat[0].stats.starttime)
+        plt.ylabel('Displacement [mm]')
+
+        if iplot > 1:
+            plt.subplot(2, 1, 2)
+            p1, = plt.loglog(f, Y.real, 'k')
+            p2, = plt.loglog(F, YY.real)
+            p3, = plt.loglog(F, YYcor, 'r')
+            p4, = plt.loglog(F, fit, 'g')
+            plt.loglog([Fc, Fc], [w0 / 100, w0], 'g')
+            plt.legend([p1, p2, p3, p4], ['Raw Spectrum',
+                                          'Used Raw Spectrum',
+                                          'Q-Corrected Spectrum',
+                                          'Fit to Spectrum'])
+            plt.title('Source Spectrum from P Pulse, w0=%e m/Hz, fc=%6.2f Hz' \
+                      % (w0, Fc))
+            plt.xlabel('Frequency [Hz]')
+            plt.ylabel('Amplitude [m/Hz]')
+            plt.grid()
+            if iplot == 3:
+                return w0, Fc, plt
+            plt.show()
+            try:
+                input()
+            except SyntaxError:
+                pass
+            plt.close(f1)
+
+    return w0, Fc
+
+
+def synthsourcespec(f, omega0, fcorner):
+    '''
+    Calculates synthetic source spectrum from given plateau and corner
+    frequency assuming Akis omega-square model.
+
+    :param: f, frequencies
+    :type:  array
+
+    :param: omega0, DC-value (plateau) of source spectrum
+    :type:  float
+
+    :param: fcorner, corner frequency of source spectrum
+    :type:  float
+    '''
+
+    # ssp = omega0 / (pow(2, (1 + f / fcorner)))
+    ssp = omega0 / (1 + pow(2, (f / fcorner)))
+
+    return ssp
+
+
+def fitSourceModel(f, S, fc0, iplot, verbosity=False):
+    '''
+    Calculates synthetic source spectrum by varying corner frequency fc.
+    Returns best approximated plateau omega0 and corner frequency, i.e. with least
+    common standard deviations.
+
+    :param:  f, frequencies
+    :type:   array
+
+    :param:  S, observed source spectrum
+    :type:   array
+
+    :param:  fc0, initial corner frequency
+    :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
+    # 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
+    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 > 100000:
+        increment = 1000
+    elif idiff <= 100000 and 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])
+        stddc = np.std(dc - S[indexdc])
+        w0.append(dc)
+        stdw0.append(stddc)
+        fc.append(FC)
+        # slope
+        indexfc = np.where((f >= FC) & (f <= fcstopr))
+        yi = dc / (1 + (f[indexfc] / FC) ** 2)
+        stdFC = np.std(yi - S[indexfc])
+        stdfc.append(stdFC)
+        STD.append(stddc + stdFC)
+
+    # get best found w0 anf fc from minimum
+    if len(STD) > 0:
+        Fc = fc[np.argmin(STD)]
+        w0 = w0[np.argmin(STD)]
+    elif len(STD) == 0:
+        Fc = fc0
+        w0 = max(S)
+    if verbosity:
+        print(
+            "fitSourceModel: best fc: {0} Hz, best w0: {1} m/Hz".format(Fc, w0))
+    if iplot >= 1:
+        plt.figure()  # iplot)
+        plt.loglog(f, S, 'k')
+        plt.loglog([f[0], Fc], [w0, w0], 'g')
+        plt.loglog([Fc, Fc], [w0 / 100, w0], 'g')
+        plt.title('Calculated Source Spectrum, Omega0=%e m/Hz, fc=%6.2f Hz' \
+                  % (w0, Fc))
+        plt.xlabel('Frequency [Hz]')
+        plt.ylabel('Amplitude [m/Hz]')
+        plt.grid()
+        if iplot == 2:
+            plt.figure()  # iplot + 1)
+            plt.subplot(311)
+            plt.plot(fc, STD, '*')
+            plt.title('Common Standard Deviations')
+            plt.xticks([])
+            plt.subplot(312)
+            plt.plot(fc, stdw0, '*')
+            plt.title('Standard Deviations of w0-Values')
+            plt.xticks([])
+            plt.subplot(313)
+            plt.plot(fc, stdfc, '*')
+            plt.title('Standard Deviations of Corner Frequencies')
+            plt.xlabel('Corner Frequencies [Hz]')
+            plt.show()
+        try:
+            input()
+        except SyntaxError:
+            pass
+        plt.close()
+
+    return w0, Fc

pylot/core/io/__init__.py

@@ -0,0 +1 @@
+# -*- coding: utf-8 -*-

pylot/core/io/data.py

@@ -0,0 +1,943 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import copy
+import logging
+import os
+
+from PySide2.QtWidgets import QMessageBox
+from obspy import read_events
+from obspy.core import read, Stream, UTCDateTime
+from obspy.core.event import Event as ObsPyEvent
+from obspy.io.sac import SacIOError
+
+import pylot.core.loc.focmec as focmec
+import pylot.core.loc.hypodd as hypodd
+import pylot.core.loc.velest as velest
+from pylot.core.io.phases import readPILOTEvent, picks_from_picksdict, \
+    picksdict_from_pilot, merge_picks, PylotParameter
+from pylot.core.util.errors import FormatError, OverwriteError
+from pylot.core.util.event import Event
+from pylot.core.util.obspyDMT_interface import qml_from_obspyDMT
+from pylot.core.util.utils import fnConstructor, full_range, check4rotated, \
+    check_for_gaps_and_merge, trim_station_components, check_for_nan
+
+
+class Data(object):
+    """
+    Data container with attributes wfdata holding ~obspy.core.stream.
+
+    :type parent: PySide2.QtWidgets.QWidget object, optional
+    :param parent: A PySide2.QtWidgets.QWidget object utilized when
+    called by a GUI to display a PySide2.QtWidgets.QMessageBox instead of printing
+    to standard out.
+    :type evtdata: ~obspy.core.event.Event object, optional
+    :param evtdata ~obspy.core.event.Event object containing all derived or
+    loaded event. Container object holding, e.g. phase arrivals, etc.
+    """
+
+    def __init__(self, parent=None, evtdata=None):
+        self._parent = parent
+        if self.getParent():
+            self.comp = parent.getComponent()
+        else:
+            self.comp = 'Z'
+            self.wfdata = Stream()
+        self._new = False
+        if isinstance(evtdata, ObsPyEvent) or isinstance(evtdata, Event):
+            pass
+        elif isinstance(evtdata, dict):
+            evt = readPILOTEvent(**evtdata)
+            evtdata = evt
+        elif isinstance(evtdata, str):
+            try:
+                cat = read_events(evtdata)
+                if len(cat) != 1:
+                    raise ValueError('ambiguous event information for file: '
+                                     '{file}'.format(file=evtdata))
+                evtdata = cat[0]
+            except TypeError as e:
+                if 'Unknown format for file' in e.message:
+                    if 'PHASES' in evtdata:
+                        picks = picksdict_from_pilot(evtdata)
+                        evtdata = ObsPyEvent()
+                        evtdata.picks = picks_from_picksdict(picks)
+                    elif 'LOC' in evtdata:
+                        raise NotImplementedError('PILOT location information '
+                                                  'read support not yet '
+                                                  'implemented.')
+                    elif 'event.pkl' in evtdata:
+                        evtdata = qml_from_obspyDMT(evtdata)
+                    else:
+                        raise e
+                else:
+                    raise e
+        else:  # create an empty Event object
+            self.setNew()
+            evtdata = ObsPyEvent()
+            evtdata.picks = []
+        self.evtdata = evtdata
+        self.wforiginal = None
+        self.cuttimes = None
+        self.dirty = False
+        self.processed = None
+
+    def __str__(self):
+        return str(self.wfdata)
+
+    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
+            wf_ids_old = [pick.waveform_id for pick in old_picks]
+            for new_pick in picks_to_add:
+                wf_id = new_pick.waveform_id
+                if wf_id in wf_ids_old:
+                    for old_pick in old_picks:
+                        comparison = [old_pick.waveform_id == new_pick.waveform_id,
+                                      old_pick.phase_hint == new_pick.phase_hint,
+                                      old_pick.method_id == new_pick.method_id]
+                        if all(comparison):
+                            del (old_pick)
+                old_picks.append(new_pick)
+        elif not other.isNew() and self.isNew():
+            new = other + self
+            self.evtdata = new.get_evt_data()
+        elif self.isNew() and other.isNew():
+            pass
+        elif rs_id == rs_id_other:
+            other.setNew()
+            return self + other
+        else:
+            raise ValueError("both Data objects have differing "
+                             "unique Event identifiers")
+        return self
+
+    def getPicksStr(self):
+        """
+        Return picks in event data
+        :return: picks seperated by newlines
+        :rtype: str
+        """
+        picks_str = ''
+        for pick in self.get_evt_data().picks:
+            picks_str += str(pick) + '\n'
+        return picks_str
+
+    def getParent(self):
+        """
+        Get PySide.QtGui.QWidget parent object
+        """
+        return self._parent
+
+    def isNew(self):
+        return self._new
+
+    def setNew(self):
+        self._new = True
+
+    def getCutTimes(self):
+        """
+        Returns earliest start and latest end of all waveform data
+        :return: minimum start time and maximum end time as a tuple
+        :rtype: (UTCDateTime, UTCDateTime)
+        """
+        if self.cuttimes is None:
+            self.updateCutTimes()
+        return self.cuttimes
+
+    def updateCutTimes(self):
+        """
+        Update cuttimes to contain earliest start and latest end time
+        of all waveform data
+        :rtype: None
+        """
+        self.cuttimes = full_range(self.getWFData())
+
+    def getEventFileName(self):
+        ID = self.getID()
+        # handle forbidden filenames especially on windows systems
+        return fnConstructor(str(ID))
+
+    def checkEvent(self, event, fcheck, forceOverwrite=False):
+        """
+        Check information in supplied event and own event and replace with own
+        information if no other information are given or forced by forceOverwrite
+        :param event: Event that supplies information for comparison
+        :type event: pylot.core.util.event.Event
+        :param fcheck: check and delete existing information
+        can be a str or a list of strings of ['manual', 'auto', 'origin', 'magnitude']
+        :type fcheck: str, [str]
+        :param forceOverwrite: Set to true to force overwrite own information. If false,
+        supplied information from event is only used if there is no own information in that
+        category (given in fcheck: manual, auto, origin, magnitude)
+        :type forceOverwrite: bool
+        :return:
+        :rtype: None
+        """
+        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):
+        """
+        Replace own origin with the one supplied in event if own origin is not
+        existing or forced by forceOverwrite = True
+        :param event: Event that supplies information for comparison
+        :type event: pylot.core.util.event.Event
+        :param forceOverwrite: always replace own information with supplied one if true
+        :type forceOverwrite: bool
+        :return:
+        :rtype: None
+        """
+        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):
+        """
+        Replace own magnitude with the one supplied in event if own magnitude is not
+        existing or forced by forceOverwrite = True
+        :param event: Event that supplies information for comparison
+        :type event: pylot.core.util.event.Event
+        :param forceOverwrite: always replace own information with supplied one if true
+        :type forceOverwrite: bool
+        :return:
+        :rtype: None
+        """
+        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):
+        """
+        Replace picks in event with own picks
+        :param event: Event that supplies information for comparison
+        :type event: pylot.core.util.event.Event
+        :param picktype: 'auto' or 'manual' picks
+        :type picktype: str
+        :return:
+        :rtype: None
+        """
+        checkflag = 1
+        picks = event.picks
+        # remove existing picks
+        for j, pick in reversed(list(enumerate(picks))):
+            try:
+                if picktype in str(pick.method_id.id):
+                    picks.pop(j)
+                    checkflag = 2
+            except AttributeError as e:
+                msg = '{}'.format(e)
+                print(e)
+                checkflag = 0
+        if checkflag > 0:
+            if checkflag == 1:
+                print("Write new %s picks to catalog." % picktype)
+            if checkflag == 2:
+                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):
+        """
+        Export event to file
+        :param fnout: basename of file
+        :param fnext: file extensions xml, cnv, obs, focmec, or/and pha
+        :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:
+            errmsg = '{0}; selected file extension {1} not ' \
+                     'supported'.format(e, fnext)
+            raise FormatError(errmsg)
+
+        if hasattr(self.get_evt_data(), 'notes'):
+            try:
+                with open(os.path.join(os.path.dirname(fnout), 'notes.txt'), 'w') as notes_file:
+                    notes_file.write(self.get_evt_data().notes)
+            except Exception as e:
+                print('Warning: Could not save notes.txt: ', str(e))
+
+        # 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:
+                    QMessageBox.warning(self, 'Warning', 'Different resource IDs!')
+                    return
+                self.checkEvent(event, fcheck)
+                self.setEvtData(event)
+
+            self.get_evt_data().write(fnout + fnext, format=evtformat)
+
+        # 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 != 0:
+                print("Manual as well as automatic picks available. Prefered the {} manual ones!".format(lendiff))
+
+
+            no_uncertainties_p = []
+            no_uncertainties_s = []
+            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':
+                            # Skipping pick if no upper_uncertainty is found and warning user
+                            if picks_copy[i].time_errors['upper_uncertainty'] is None:
+                                #print("{1} P-Pick of station {0} does not have upper_uncertainty and cant be checked".format(
+                                 #   picks_copy[i].waveform_id.station_code,
+                                  #  picks_copy[i].method_id))
+                                if not picks_copy[i].waveform_id.station_code in no_uncertainties_p:
+                                    no_uncertainties_p.append(picks_copy[i].waveform_id.station_code)
+                                continue
+
+                            #print ("checking for upper_uncertainty")
+                            if  (picks_copy[i].time_errors['uncertainty'] is None) or \
+                                    (picks_copy[i].time_errors['upper_uncertainty'] >= upperErrors[0]):
+                                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))
+                                del picks_copy[i]
+                                break
+                        if picks_copy[i].phase_hint[0] == 'S':
+
+                            # Skipping pick if no upper_uncertainty is found and warning user
+                            if picks_copy[i].time_errors['upper_uncertainty'] is None:
+                                #print("{1} S-Pick of station {0} does not have upper_uncertainty and cant be checked".format(
+                                    #picks_copy[i].waveform_id.station_code,
+                                    #picks_copy[i].method_id))
+                                if not picks_copy[i].waveform_id.station_code in no_uncertainties_s:
+                                    no_uncertainties_s.append(picks_copy[i].waveform_id.station_code)
+                                continue
+
+
+                            if (picks_copy[i].time_errors['uncertainty'] is None) or \
+                                (picks_copy[i].time_errors['upper_uncertainty'] >= upperErrors[1]):
+                                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))
+                                del picks_copy[i]
+                                break
+            for s in no_uncertainties_p:
+                print("P-Pick of station {0} does not have upper_uncertainty and cant be checked".format(s))
+            for s in no_uncertainties_s:
+                print("S-Pick of station {0} does not have upper_uncertainty and cant be checked".format(s))
+
+            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()
+                    # Adding A0/Generic Amplitude to .obs file
+                    # l2 = []
+                    # for li in l:
+                    #    for amp in evtdata_org.amplitudes:
+                    #        if amp.waveform_id.station_code == li[0:5].strip():
+                    #            li = li[0:64] + '{:0.2e}'.format(amp.generic_amplitude) + li[73:-1] + '\n'
+                    #            l2.append(li)
+                    # l = l2
+                    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))
+            if fnext == '_focmec.in':
+                try:
+                    parameter = PylotParameter()
+                    logging.warning('Using default input parameter')
+                    focmec.export(picks_copy, fnout + fnext, parameter, eventinfo=self.get_evt_data())
+                except KeyError as e:
+                    raise KeyError('''{0} export format
+                                     not implemented: {1}'''.format(evtformat, e))
+            if fnext == '.pha':
+                try:
+                    parameter = PylotParameter()
+                    logging.warning('Using default input parameter')
+                    hypodd.export(picks_copy, fnout + fnext, parameter, eventinfo=self.get_evt_data())
+                except KeyError as e:
+                    raise KeyError('''{0} export format
+                                     not implemented: {1}'''.format(evtformat, e))
+
+    def getComp(self):
+        """
+        Get component (ZNE)
+        """
+        return self.comp
+
+    def getID(self):
+        """
+        Get unique resource id
+        """
+        try:
+            return self.evtdata.get('resource_id').id
+        except:
+            return None
+
+    def filterWFData(self, kwargs):
+        """
+        Filter waveform data
+        :param kwargs: arguments to pass through to filter function
+        """
+        data = self.getWFData()
+        data.detrend('linear')
+        data.taper(0.02, type='cosine')
+        data.filter(**kwargs)
+        self.dirty = True
+
+    def setWFData(self, fnames, fnames_alt=None, checkRotated=False, metadata=None, tstart=0, tstop=0):
+        """
+        Clear current waveform data and set given waveform data
+        :param fnames: waveform data names to append
+        :param fnames_alt: alternative data to show (e.g. synthetic/processed)
+        :type fnames: list
+        """
+        def check_fname_exists(filenames: list) -> list:
+            if filenames:
+                filenames = [fn for fn in filenames if os.path.isfile(fn)]
+            return filenames
+
+        self.wfdata = Stream()
+        self.wforiginal = None
+        self.wf_alt = Stream()
+        if tstart == tstop:
+            tstart = tstop = None
+        self.tstart = tstart
+        self.tstop = tstop
+
+        # remove directories
+        fnames = check_fname_exists(fnames)
+        fnames_alt = check_fname_exists(fnames_alt)
+
+        # if obspy_dmt:
+        #     wfdir = 'raw'
+        #     self.processed = False
+        #     for fname in fnames:
+        #         if fname.endswith('processed'):
+        #             wfdir = 'processed'
+        #             self.processed = True
+        #             break
+        #     for fpath in fnames:
+        #         if fpath.endswith(wfdir):
+        #             wffnames = [os.path.join(fpath, fname) for fname in os.listdir(fpath)]
+        #         if 'syngine' in fpath.split('/')[-1]:
+        #             wffnames_syn = [os.path.join(fpath, fname) for fname in os.listdir(fpath)]
+        # else:
+        #     wffnames = fnames
+        if fnames is not None:
+            self.appendWFData(fnames)
+            if fnames_alt is not None:
+                self.appendWFData(fnames_alt, alternative=True)
+        else:
+            return False
+
+        # various pre-processing steps:
+        # remove possible underscores in station names
+        # self.wfdata = remove_underscores(self.wfdata)
+        # check for gaps and merge
+        self.wfdata, _ = check_for_gaps_and_merge(self.wfdata)
+        # check for nans
+        check_for_nan(self.wfdata)
+        # check for stations with rotated components
+        if checkRotated and metadata is not None:
+            self.wfdata = check4rotated(self.wfdata, metadata, verbosity=0)
+        # trim station components to same start value
+        trim_station_components(self.wfdata, trim_start=True, trim_end=False)
+
+        # make a copy of original data
+        self.wforiginal = self.getWFData().copy()
+        self.dirty = False
+        return True
+
+    def appendWFData(self, fnames, alternative=False):
+        """
+        Read waveform data from fnames and append it to current wf data
+        :param fnames: waveform data to append
+        :type fnames: list
+        """
+        assert isinstance(fnames, list), "input parameter 'fnames' is " \
+                                         "supposed to be of type 'list' " \
+                                         "but is actually" \
+                                         " {0}".format(type(fnames))
+        if self.dirty:
+            self.resetWFData()
+
+        orig_or_alternative_data = {True: self.wf_alt,
+                                    False: self.wfdata}
+
+        warnmsg = ''
+        for fname in set(fnames):
+            try:
+                orig_or_alternative_data[alternative] += read(fname, starttime=self.tstart, endtime=self.tstop)
+            except TypeError:
+                try:
+                    orig_or_alternative_data[alternative] += read(fname, format='GSE2', starttime=self.tstart, endtime=self.tstop)
+                except Exception as e:
+                    try:
+                        orig_or_alternative_data[alternative] += read(fname, format='SEGY', starttime=self.tstart,
+                                                                      endtime=self.tstop)
+                    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 in appendWFData: unable to read waveform data\n' + warnmsg
+            print(warnmsg)
+
+    def getWFData(self):
+        return self.wfdata
+
+    def getOriginalWFData(self):
+        return self.wforiginal
+
+    def getAltWFdata(self):
+        return self.wf_alt
+
+    def resetWFData(self):
+        """
+        Set waveform data to original waveform data
+        """
+        if self.getOriginalWFData():
+            self.wfdata = self.getOriginalWFData().copy()
+        else:
+            self.wfdata = Stream()
+        self.dirty = False
+
+    def resetPicks(self):
+        """
+        Clear all picks from event
+        """
+        self.get_evt_data().picks = []
+
+    def get_evt_data(self):
+        return self.evtdata
+
+    def setEvtData(self, event):
+        self.evtdata = event
+
+    def applyEVTData(self, data, typ='pick'):
+        """
+        Either takes an `obspy.core.event.Event` object and applies all new
+        information on the event to the actual data if typ is 'event or
+        creates ObsPy pick objects and append it to the picks list from the
+        PyLoT dictionary contain all picks if type is pick
+        :param data: data to apply, either picks or complete event
+        :type data:
+        :param typ: which event data to apply, 'pick' or 'event'
+        :type typ: str
+        :param authority_id: (currently unused)
+        :type: str
+        :raise OverwriteError:
+        """
+
+        def applyPicks(picks):
+            """
+            Creates ObsPy pick objects and append it to the picks list from the
+            PyLoT dictionary contain all picks.
+            :param picks:
+            :raise OverwriteError: raises an OverwriteError if the picks list is
+             not empty. The GUI will then ask for a decision.
+            """
+            # firstonset = find_firstonset(picks)
+            # check for automatic picks
+            print("Writing phases to ObsPy-quakeml file")
+            for key in picks:
+                if not picks[key].get('P'):
+                    continue
+                if picks[key]['P']['picker'] == 'auto':
+                    print("Existing auto-picks will be overwritten in pick-dictionary!")
+                    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')
+            #     ID = ResourceIdentifier('event/' + fonset_str)
+            #     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 event is None:
+                print("applyEvent: Received None")
+                return
+            if self.isNew():
+                self.setEvtData(event)
+            else:
+                # prevent overwriting original pick information
+                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
+                event_old.update(event)
+
+        applydata = {'pick': applyPicks,
+                     'event': applyEvent}
+
+        applydata[typ](data)
+        self._new = False
+
+
+class GenericDataStructure(object):
+    """
+    GenericDataBase type holds all information about the current data-
+    base working on.
+    """
+
+    def __init__(self, **kwargs):
+
+        self.allowedFields = []
+        self.expandFields = ['root']
+        self.dsFields = {}
+
+        self.modifyFields(**kwargs)
+
+    def modifyFields(self, **kwargs):
+
+        """
+
+        :param kwargs:
+        """
+        assert isinstance(kwargs, dict), 'dictionary type object expected'
+
+        if not self.extraAllowed():
+            kwargs = self.updateNotAllowed(kwargs)
+
+        for key, value in kwargs.items():
+            key = str(key).lower()
+            if value is not None:
+                if type(value) not in (str, int, float):
+                    for n, val in enumerate(value):
+                        value[n] = str(val)
+                else:
+                    value = str(value)
+            try:
+                self.setFieldValue(key, value)
+            except KeyError as e:
+                errmsg = ''
+                errmsg += 'WARNING:\n'
+                errmsg += 'unable to set values for datastructure fields\n'
+                errmsg += '%s; desired value was: %s\n' % (e, value)
+                print(errmsg)
+
+    def isField(self, key):
+        """
+
+        :param key:
+        :return:
+        """
+        return key in self.getFields().keys()
+
+    def getFieldValue(self, key):
+        """
+
+        :param key:
+        :return:
+        """
+        if self.isField(key):
+            return self.getFields()[key]
+        else:
+            return
+
+    def setFieldValue(self, key, value):
+        """
+
+        :param key:
+        :param value:
+        :raise KeyError:
+        """
+        if not self.extraAllowed() and key not in self.getAllowed():
+            raise KeyError
+        else:
+            if not self.isField(key):
+                print('creating new field "%s"' % key)
+            self.getFields()[key] = value
+
+    def getFields(self):
+        """
+
+
+        :return:
+        """
+        return self.dsFields
+
+    def getExpandFields(self):
+        """
+
+
+        :return:
+        """
+        return self.expandFields
+
+    def setExpandFields(self, keys):
+        """
+
+        :param keys:
+        """
+        expandFields = []
+        for key in keys:
+            if self.isField(key):
+                expandFields.append(key)
+        self.expandFields = expandFields
+
+    def getAllowed(self):
+        """
+
+
+        :return:
+        """
+        return self.allowedFields
+
+    def extraAllowed(self):
+        """
+
+
+        :return:
+        """
+        return not self.allowedFields
+
+    def updateNotAllowed(self, kwargs):
+        """
+
+        :param kwargs:
+        :return:
+        """
+        for key in kwargs:
+            if key not in self.getAllowed():
+                kwargs.__delitem__(key)
+        return kwargs
+
+    def hasSuffix(self):
+        """
+
+
+        :return:
+        """
+        try:
+            self.getFieldValue('suffix')
+        except KeyError:
+            return False
+        else:
+            if self.getFieldValue('suffix'):
+                return True
+        return False
+
+    def expandDataPath(self):
+        """
+
+
+        :return:
+        """
+        expandList = []
+        for item in self.getExpandFields():
+            expandList.append(self.getFieldValue(item))
+        if self.hasSuffix():
+            expandList.append('*%s' % self.getFieldValue('suffix'))
+        return os.path.join(*expandList)
+
+    def getCatalogName(self):
+        """
+
+
+        :return:
+        """
+        return os.path.join(self.getFieldValue('root'), 'catalog.qml')
+
+
+class PilotDataStructure(GenericDataStructure):
+    """
+    Object containing the data access information for the old PILOT data
+    structure.
+    """
+
+    def __init__(self, **fields):
+        if not fields:
+            fields = {'database': '',
+                      'root': ''}
+
+        GenericDataStructure.__init__(self, **fields)
+
+        self.setExpandFields(['root', 'database'])
+
+
+class ObspyDMTdataStructure(GenericDataStructure):
+    """
+    Object containing the data access information for the old PILOT data
+    structure.
+    """
+
+    def __init__(self, **fields):
+        if not fields:
+            fields = {'database': '',
+                      'root': ''}
+
+        GenericDataStructure.__init__(self, **fields)
+
+        self.setExpandFields(['root', 'database'])
+
+
+class SeiscompDataStructure(GenericDataStructure):
+    """
+    Dictionary containing the data access information for an SDS data archive:
+
+    :param str dataType: Desired data type. Default: ``'waveform'``
+    :param sdate, edate: Either date string or an instance of
+         :class:`obspy.core.utcdatetime.UTCDateTime. Default: ``None``
+    :type sdate, edate: str or UTCDateTime or None
+    """
+
+    def __init__(self, rootpath='/data/SDS', dataformat='MSEED',
+                 filesuffix=None, **kwargs):
+        super(GenericDataStructure, self).__init__()
+
+        edate = UTCDateTime()
+        halfyear = UTCDateTime('1970-07-01')
+        sdate = UTCDateTime(edate - halfyear)
+        del halfyear
+
+        year = ''
+        if not edate.year == sdate.year:
+            nyears = edate.year - sdate.year
+            for yr in range(nyears):
+                year += '{0:04d},'.format(sdate.year + yr)
+            year = '{' + year[:-1] + '}'
+        else:
+            year = '{0:04d}'.format(sdate.year)
+
+        # SDS fields' default values
+        # definitions from
+        # http://www.seiscomp3.org/wiki/doc/applications/slarchive/SDS
+
+        self.dsFields = {'root': '/data/SDS', 'YEAR': year, 'NET': '??',
+                         'STA': '????', 'CHAN': 'HH?', 'TYPE': 'D', 'LOC': '',
+                         'DAY': '{0:03d}'.format(sdate.julday)
+                         }
+        self.modifiyFields(**kwargs)
+
+    def modifiyFields(self, **kwargs):
+        """
+
+        :param kwargs:
+        """
+        if kwargs and isinstance(kwargs, dict):
+            for key, value in kwargs.iteritems():
+                key = str(key)
+                if type(value) not in (str, int, float):
+                    for n, val in enumerate(value):
+                        value[n] = str(val)
+                else:
+                    value = str(value)
+                try:
+                    self.setFieldValue(key, value)
+                except KeyError as e:
+                    errmsg = ''
+                    errmsg += 'WARNING:\n'
+                    errmsg += 'unable to set values for SDS fields\n'
+                    errmsg += '%s; desired value was: %s\n' % (e, value)
+                    print(errmsg)
+
+    def setFieldValue(self, key, value):
+        """
+
+        :param key:
+        :param value:
+        """
+        if self.isField(key):
+            self.getFields()[key] = value
+        else:
+            print('Warning: trying to set value of non-existent field '
+                  '{field}'.format(field=key))
+
+    def expandDataPath(self):
+        """
+
+
+        :return:
+        """
+        fullChan = '{0}.{1}'.format(self.getFields()['CHAN'], self.getType())
+        dataPath = os.path.join(self.getFields()['SDSdir'],
+                                self.getFields()['YEAR'],
+                                self.getFields()['NET'],
+                                self.getFields()['STA'],
+                                fullChan,
+                                '*{0}'.format(self.getFields()['DAY']))
+        return dataPath

pylot/core/io/default_parameters.py

@@ -0,0 +1,616 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import numpy as np
+
+"""
+Default parameters used for picking
+"""
+
+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 ("active", "local", "regional" or "global")',
+                       'value': 'local',
+                       'namestring': 'Array extent'},
+
+            'invdir': {'type': str,
+                       'tooltip': 'full path to  inventory or dataless-seed file',
+                       'value': '',
+                       'namestring': 'Inventory directory'},
+
+            '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': '',
+                        '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.,
+                   'min': 0.,
+                   'max': np.inf,
+                   'namestring': 'P-velocity'},
+
+            'rho': {'type': float,
+                    'tooltip': 'average rock density [kg/m^3]',
+                    'value': 2500.,
+                    'min': 0.,
+                    'max': np.inf,
+                    '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,
+                       'min': -np.inf,
+                       'max': np.inf,
+                       '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,
+                      'min': -np.inf,
+                      'max': np.inf,
+                      'namestring': 'P stop'},
+
+            'sstart': {'type': float,
+                       'tooltip': 'start time [s] relative to P-onset for calculating CF for S-picking',
+                       'value': -1.0,
+                       'min': -np.inf,
+                       'max': np.inf,
+                       'namestring': 'S start'},
+
+            'sstop': {'type': float,
+                      'tooltip': 'end time [s] after P-onset for calculating CF for S-picking',
+                      'value': 10.0,
+                      'min': -np.inf,
+                      'max': np.inf,
+                      'namestring': 'S stop'},
+
+            'bpz1': {'type': (float, float),
+                     'tooltip': 'lower/upper corner freq. of first band pass filter Z-comp. [Hz]',
+                     'value': (2, 20),
+                     'min': (0., 0.),
+                     'max': (np.inf, np.inf),
+                     '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),
+                     'min': (0., 0.),
+                     'max': (np.inf, np.inf),
+                     '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),
+                     'min': (0., 0.),
+                     'max': (np.inf, np.inf),
+                     '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),
+                     'min': (0., 0.),
+                     'max': (np.inf, np.inf),
+                     '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,
+                     'min': 0.,
+                     'max': np.inf,
+                     'namestring': 'LTA window'},
+
+            'hosorder': {'type': int,
+                         'tooltip': 'for HOS-picker, order of Higher Order Statistics',
+                         'value': 4,
+                         'min': 0,
+                         'max': np.inf,
+                         'namestring': 'HOS order'},
+
+            'Parorder': {'type': int,
+                         'tooltip': 'for AR-picker, order of AR process of Z-component',
+                         'value': 2,
+                         'min': 0,
+                         'max': np.inf,
+                         '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,
+                       'min': 0.,
+                       'max': np.inf,
+                       '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,
+                        'min': 0.,
+                        'max': np.inf,
+                        '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,
+                       'min': 0.,
+                       'max': np.inf,
+                       '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,
+                        'min': 0.,
+                        'max': np.inf,
+                        'namestring': 'AR pred. window Z 2'},
+
+            'addnoise': {'type': float,
+                         'tooltip': 'add noise to seismogram for stable AR prediction',
+                         'value': 0.001,
+                         'min': 0.,
+                         'max': np.inf,
+                         '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),
+                      'min': (0., 0., 0., 0.),
+                      'max': (np.inf, np.inf, np.inf, np.inf),
+                      '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,
+                         'min': 0.,
+                         'max': np.inf,
+                         '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,
+                           'min': 0.,
+                           'max': np.inf,
+                           'namestring': 'Recal. window P'},
+
+            'aictsmooth': {'type': float,
+                           'tooltip': 'for HOS/AR, take average of samples for smoothing of AIC-function [s]',
+                           'value': 0.2,
+                           'min': 0.,
+                           'max': np.inf,
+                           'namestring': 'AIC smooth P'},
+
+            'tsmoothP': {'type': float,
+                         'tooltip': 'for HOS/AR, take average of samples in this time window for smoothing CF [s]',
+                         'value': 0.1,
+                         'min': 0.,
+                         'max': np.inf,
+                         'namestring': 'CF smooth P'},
+
+            'ausP': {'type': float,
+                     'tooltip': 'for HOS/AR, artificial uplift of samples (aus) of CF (P)',
+                     'value': 0.001,
+                     'min': 0.,
+                     'max': np.inf,
+                     'namestring': 'Artificial uplift P'},
+
+            'nfacP': {'type': float,
+                      'tooltip': 'for HOS/AR, noise factor for noise level determination (P)',
+                      'value': 1.3,
+                      'min': 0.,
+                      'max': np.inf,
+                      '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,
+                       'min': 0.,
+                       'max': np.inf,
+                       '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,
+                        'min': 0.,
+                        'max': np.inf,
+                        '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,
+                       'min': 0.,
+                       'max': np.inf,
+                       '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,
+                        'min': 0.,
+                        'max': np.inf,
+                        'namestring': 'AR pred. window H 2'},
+
+            'Sarorder': {'type': int,
+                         'tooltip': 'for AR-picker, order of AR process of H-components',
+                         'value': 4,
+                         'min': 0,
+                         'max': np.inf,
+                         'namestring': 'AR order S'},
+
+            'Srecalcwin': {'type': float,
+                           'tooltip': 'for AR-picker, window length [s] for recalculation of CF (2nd pick) (H)',
+                           'value': 5.0,
+                           'min': 0.,
+                           'max': np.inf,
+                           'namestring': 'Recal. window S'},
+
+            'pickwinS': {'type': float,
+                         'tooltip': 'for initial AIC pick, length of S-pick window [s]',
+                         'value': 3.0,
+                         'min': 0.,
+                         'max': np.inf,
+                         '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),
+                      'min': (0., 0., 0., 0.),
+                      'max': (np.inf, np.inf, np.inf, np.inf),
+                      'namestring': ('SNR windows S', 'Noise', 'Safety', 'Signal', 'Slope')},
+
+            'aictsmoothS': {'type': float,
+                            'tooltip': 'for AIC-picker, take average of samples in this time window for smoothing of AIC-function [s]',
+                            'value': 0.5,
+                            'min': 0.,
+                            'max': np.inf,
+                            'namestring': 'AIC smooth S'},
+
+            'tsmoothS': {'type': float,
+                         'tooltip': 'for AR-picker, take average of samples for smoothing CF [s] (S)',
+                         'value': 0.7,
+                         'min': 0.,
+                         'max': np.inf,
+                         'namestring': 'CF smooth S'},
+
+            'ausS': {'type': float,
+                     'tooltip': 'for HOS/AR, artificial uplift of samples (aus) of CF (S)',
+                     'value': 0.9,
+                     'min': 0.,
+                     'max': np.inf,
+                     'namestring': 'Artificial uplift S'},
+
+            'nfacS': {'type': float,
+                      'tooltip': 'for AR-picker, noise factor for noise level determination (S)',
+                      'value': 1.5,
+                      'min': 0.,
+                      'max': np.inf,
+                      '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.,
+                         'min': 0.,
+                         'max': np.inf,
+                         'namestring': 'Min SNR'},
+
+            'fmpickwin': {'type': float,
+                          'tooltip': 'pick window [s] around P onset for calculating zero crossings',
+                          'value': 0.2,
+                          'min': 0.,
+                          'max': np.inf,
+                          '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),
+                            'min': (0., 0., 0., 0.),
+                            'max': (np.inf, np.inf, np.inf, np.inf),
+                            '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),
+                            'min': (0., 0., 0., 0.),
+                            'max': (np.inf, np.inf, np.inf, np.inf),
+                            '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,
+                             'min': 0.,
+                             'max': np.inf,
+                             'namestring': 'Min. slope P'},
+
+            'minAICPSNR': {'type': float,
+                           'tooltip': 'below this SNR the initial P pick is rejected',
+                           'value': 1.1,
+                           'min': 0.,
+                           'max': np.inf,
+                           'namestring': 'Min. SNR P'},
+
+            'minAICSslope': {'type': float,
+                             'tooltip': 'below this slope [counts/s] the initial S pick is rejected',
+                             'value': 1.,
+                             'min': 0.,
+                             'max': np.inf,
+                             'namestring': 'Min. slope S'},
+
+            'minAICSSNR': {'type': float,
+                           'tooltip': 'below this SNR the initial S pick is rejected',
+                           'value': 1.5,
+                           'min': 0.,
+                           'max': np.inf,
+                           'namestring': 'Min. SNR S'},
+
+            'minsiglength': {'type': float,
+                             'tooltip': 'length of signal part for which amplitudes must exceed noiselevel [s]',
+                             'value': 1.,
+                             'min': 0.,
+                             'max': np.inf,
+                             'namestring': 'Min. signal length'},
+
+            'noisefactor': {'type': float,
+                            'tooltip': 'noiselevel*noisefactor=threshold',
+                            'value': 1.0,
+                            'min': 0.,
+                            'max': np.inf,
+                            'namestring': 'Noise factor'},
+
+            'minpercent': {'type': float,
+                           'tooltip': 'required percentage of amplitudes exceeding threshold',
+                           'value': 10.,
+                           'min': 0.,
+                           'max': np.inf,
+                           'namestring': 'Min amplitude [%]'},
+
+            'zfac': {'type': float,
+                     'tooltip': 'P-amplitude must exceed at least zfac times RMS-S amplitude',
+                     'value': 1.5,
+                     'min': 0.,
+                     'max': np.inf,
+                     'namestring': 'Z factor'},
+
+            'mdttolerance': {'type': float,
+                             'tooltip': 'maximum allowed deviation of P picks from median [s]',
+                             'value': 6.0,
+                             'min': 0.,
+                             'max': np.inf,
+                             'namestring': 'Median tolerance'},
+
+            'wdttolerance': {'type': float,
+                             'tooltip': 'maximum allowed deviation from Wadati-diagram',
+                             'value': 1.0,
+                             'min': 0.,
+                             'max': np.inf,
+                             '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,
+                           'min': 0.,
+                           'max': np.inf,
+                           '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.),
+                          'min': (-np.inf, -np.inf, -np.inf),
+                          'max': (np.inf, np.inf, np.inf),
+                          '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.),
+                           'min': (0., -np.inf),
+                           'max': (np.inf, np.inf),
+                           'namestring': ('Local mag. scaling', '', '')},
+
+            'minfreq': {'type': (float, float),
+                        'tooltip': 'Lower filter frequency [P, S]',
+                        'value': (1.0, 1.0),
+                        'min': (0., 0.),
+                        'max': (np.inf, np.inf),
+                        'namestring': ('Lower freq.', 'P', 'S')},
+
+            'maxfreq': {'type': (float, float),
+                        'tooltip': 'Upper filter frequency [P, S]',
+                        'value': (10.0, 10.0),
+                        'min': (0., 0.),
+                        'max': (np.inf, np.inf),
+                        'namestring': ('Upper freq.', 'P', 'S')},
+
+            'filter_order': {'type': (int, int),
+                             'tooltip': 'filter order [P, S]',
+                             'value': (2, 2),
+                             'min': (0, 0),
+                             'max': (np.inf, np.inf),
+                             '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': None,
+                           'namestring': 'TauPy model'},
+
+            'taup_phases': {'type': str,
+                            'tooltip': 'Specify possible phases for TauPy (comma separated). See Obspy TauPy documentation for possible values.',
+                            'value': 'ttall',
+                            'namestring': 'TauPy phases'},
+            }
+
+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',
+        'taup_phases',
+        '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/getEventListFromXML.py

@@ -0,0 +1,84 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+"""
+   Script to get event parameters from PyLoT-xml file to write
+   them into eventlist.
+   LK, igem, 03/2021
+   Edited for use in PyLoT
+   JG, igem, 01/2022
+"""
+
+import os
+import argparse
+import numpy as np
+import matplotlib.pyplot as plt
+import glob
+
+from obspy.core.event import read_events
+from pyproj import Proj
+
+"""
+Creates an eventlist file summarizing all events found in a certain folder. Only called by pressing UI Button eventlis_xml_action
+
+:rtype:
+:param path: Path to root folder where single Event folder are to found
+"""
+
+
+def geteventlistfromxml(path, outpath):
+    p = Proj(proj='utm', zone=32, ellps='WGS84')
+
+    # open eventlist file and write header
+    evlist = outpath + '/eventlist'
+    evlistobj = open(evlist, 'w')
+    evlistobj.write(
+        'EventID      Date      To    Lat    Lon     EAST    NORTH  Dep  Ml  NoP  NoS RMS  errH  errZ  Gap \n')
+
+    # data path
+    dp = path + "/e*/*.xml"
+    # list of all available xml-files
+    xmlnames = glob.glob(dp)
+
+    # read all onset weights
+    for names in xmlnames:
+        print("Getting location parameters from {}".format(names))
+        cat = read_events(names)
+        try:
+            st = cat.events[0].origins[0].time
+            Lat = cat.events[0].origins[0].latitude
+            Lon = cat.events[0].origins[0].longitude
+            EAST, NORTH = p(Lon, Lat)
+            Dep = cat.events[0].origins[0].depth / 1000
+            Ml = cat.events[0].magnitudes[1].mag
+            NoP = []
+            NoS = []
+        except IndexError:
+            print('Insufficient data found for event (not localised): ' + names.split('/')[-1].split('_')[-1][
+                                                                          :-4] + ' Skipping event for eventlist.')
+            continue
+
+        for i in range(len(cat.events[0].origins[0].arrivals)):
+            if cat.events[0].origins[0].arrivals[i].phase == 'P':
+                NoP.append(cat.events[0].origins[0].arrivals[i].phase)
+            elif cat.events[0].origins[0].arrivals[i].phase == 'S':
+                NoS.append(cat.events[0].origins[0].arrivals[i].phase)
+        # NoP = cat.events[0].origins[0].quality.used_station_count
+        errH = cat.events[0].origins[0].origin_uncertainty.max_horizontal_uncertainty
+        errZ = cat.events[0].origins[0].depth_errors.uncertainty
+        Gap = cat.events[0].origins[0].quality.azimuthal_gap
+        # evID = names.split('/')[6]
+        evID = names.split('/')[-1].split('_')[-1][:-4]
+        Date = str(st.year) + str('%02d' % st.month) + str('%02d' % st.day)
+        To = str('%02d' % st.hour) + str('%02d' % st.minute) + str('%02d' % st.second) + \
+             '.' + str('%06d' % st.microsecond)
+
+        # write into eventlist
+        evlistobj.write('%s %s %s %9.6f %9.6f %13.6f %13.6f %8.6f %3.1f %d %d NaN %d %d %d\n' % (evID, \
+                                                                                                 Date, To, Lat, Lon,
+                                                                                                 EAST, NORTH, Dep, Ml,
+                                                                                                 len(NoP), len(NoS),
+                                                                                                 errH, errZ, Gap))
+        print('Adding Event ' + names.split('/')[-1].split('_')[-1][:-4] + ' to eventlist')
+    print('Eventlist created and saved in: ' + outpath)
+    evlistobj.close()

pylot/core/io/inputs.py

@@ -0,0 +1,504 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from pylot.core.io import default_parameters
+from pylot.core.util.errors import ParameterError
+
+
+class PylotParameter(object):
+    '''
+    PylotParameter is a parameter type object capable to read and/or write
+    parameter ASCII.
+
+    :param fn str: Filename of the input file
+
+    Parameters are given for example as follows:
+    ==========  ==========  =======================================
+    Name        Value       Comment
+    ==========  ==========  =======================================
+    phl         S           # phaselabel
+    ff1         0.1         # freqmin
+    ff2         0.5         # freqmax
+    tdet        6.875       # det-window_(s)_for_ar
+    tpred       2.5         # pred-window_(s)_for_ar
+    order       4           # order_of_ar
+    fnoise      0           # noise_level_for_ar
+    suppp       7           # envelopecoeff
+    tolt        300         # (s)time around arrival time
+    f1tpwt      4           # propfact_minfreq_secondtaper
+    pickwindow  9           # length_of_pick_window
+    w1          1           # length_of_smoothing_window
+    w2          0.37        # cf(i-1)*(1+peps)_for_local_min
+    w3          0.25        # cf(i-1)*(1+peps)_for_local_min
+    tslope      0.8;2       # slope_det_window_loc_glob
+    aerr        30;60       # adjusted_error_slope_fitting_loc_glob
+    tsn         20;5;20;10  # length_signal_window_S/N
+    proPh       Sn          # nextprominentphase
+    ==========  ==========  =======================================
+    '''
+
+    def __init__(self, fnin=None, fnout=None, verbosity=0, **kwargs):
+        '''
+        Initialize parameter object:
+
+        io content of an ASCII file an form a type consistent dictionary
+        contain all parameters.
+        '''
+
+        self.__init_default_paras()
+        self.__init_subsettings()
+        self.__filename = fnin
+        self.__parameter = {}
+        self._verbosity = verbosity
+        self._parFileCont = {}
+        # io from parsed arguments alternatively
+        for key, val in kwargs.items():
+            self._parFileCont[key] = val
+        self.from_file()
+        if fnout:
+            self.export2File(fnout)
+
+    # Human-readable string representation of the object
+    def __str__(self):
+        string = ''
+        string += 'Automated picking parameter:\n\n'
+        if self.__parameter:
+            for key, value in self.iteritems():
+                string += '%s:\t\t%s\n' % (key, value)
+        else:
+            string += 'Empty parameter dictionary.'
+        return string
+
+    # Set default values of parameter names
+    def __init_default_paras(self):
+        """set default values of parameter names"""
+        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 "PylotParameter('%s')" % self.__filename
+
+    # Boolean test
+    def __nonzero__(self):
+        return bool(self.__parameter)
+
+    def __getitem__(self, key):
+        try:
+            return self.__parameter[key]
+        except:
+            return None
+
+    def __setitem__(self, key, value):
+        try:
+            value = self.check_range(value, self.__defaults[key]['max'], self.__defaults[key]['min'])
+        except KeyError:
+            # no min/max values in defaults
+            pass
+        self.__parameter[key] = value
+
+    def __delitem__(self, key):
+        del self.__parameter[key]
+
+    def __iter__(self):
+        return iter(self.__parameter)
+
+    def __len__(self):
+        return len(self.__parameter.keys())
+
+    def iteritems(self):
+        """
+        Iterate over parameters
+        :return: key, value tupel
+        :rtype:
+        """
+        for key, value in self.__parameter.items():
+            yield key, value
+
+    def hasParam(self, parameter):
+        """
+        Check if parameter is in keys
+        :param parameter: parameter to look for in keys
+        :type parameter:
+        :return:
+        :rtype: bool
+        """
+        return parameter in self.__parameter.keys()
+
+    def get(self, *args):
+        """
+        Get first available parameter in args
+        :param args:
+        :type args:
+        :return:
+        :rtype:
+        """
+        try:
+            for param in args:
+                try:
+                    return self.__getitem__(param)
+                except KeyError as e:
+                    self._printParameterError(e)
+                    raise ParameterError(e)
+        except TypeError:
+            try:
+                return self.__getitem__(args)
+            except KeyError as e:
+                self._printParameterError(e)
+                raise ParameterError(e)
+
+    def get_defaults(self):
+        """
+        get default parameters
+        :return:
+        :rtype: dict
+        """
+        return self.__defaults
+
+    def get_main_para_names(self):
+        """
+        Get main parameter names
+        :return: list of keys available in parameters
+        :rtype:
+        """
+        return self._settings_main
+
+    def get_special_para_names(self):
+        """
+        Get pick parameter names
+        :return: list of keys available in parameters
+        :rtype:
+        """
+        return self._settings_special_pick
+
+    def get_all_para_names(self):
+        """
+        Get all parameter names
+        :return:
+        :rtype: list
+        """
+        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 reinit_default_parameters(self):
+        self.__init_default_paras()
+
+    @staticmethod
+    def check_range(value, max_value, min_value):
+        """
+        Check if value is within the min/max values defined in default_parameters. Works for tuple and scalar values.
+        :param value: Value to be checked against min/max range
+        :param max_value: Maximum allowed value, tuple or scalar
+        :param min_value: Minimum allowed value, tuple or scalar
+        :return: value tuple/scalar clamped to the valid range
+
+        >>> checkRange(-5, 10, 0)
+         0
+         >>> checkRange((-5., 100.), (10., 10.), (0., 0.))
+         (0.0, 10.0)
+        """
+        try:
+            # Try handling tuples by comparing their elements
+            comparisons = [(a > b) for a, b in zip(value, max_value)]
+            if True in comparisons:
+                value = tuple(max_value[i] if comp else value[i] for i, comp in enumerate(comparisons))
+            comparisons = [(a < b) for a, b in zip(value, min_value)]
+            if True in comparisons:
+                value = tuple(min_value[i] if comp else value[i] for i, comp in enumerate(comparisons))
+        except TypeError:
+            value = max(min_value, min(max_value, value))
+        return value
+
+    def checkValue(self, param, value):
+        """
+        Check type of value against expected type of param.
+        Print warning message if type check fails
+        :param param:
+        :type param:
+        :param value:
+        :type value:
+        :return:
+        :rtype:
+        """
+        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):
+        """
+        set parameter param to value
+        :param param:
+        :type param:
+        :param value:
+        :type value:
+        :return:
+        :rtype: None
+        """
+        self.__setitem__(param, value)
+
+    def setParam(self, **kwargs):
+        """
+        Set multiple parameters
+        :param kwargs:
+        :type kwargs:
+        :return:
+        :rtype: None
+        """
+        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):
+        """
+        Reset current parameters to default parameters
+        :return:
+        :rtype: None
+        """
+        defaults = self.get_defaults()
+        for param_name, param in defaults.items():
+            self.setParamKV(param_name, param['value'])
+
+    def from_file(self, fnin=None):
+        """
+        read parameters from file and set values to read values
+        :param fnin: filename
+        :type fnin:
+        :return:
+        :rtype: 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):
+        """
+        Export parameters to file
+        :param fnout: Filename of export file
+        :type fnout: str
+        :return:
+        :rtype:
+        """
+        fid_out = open(fnout, 'w')
+        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):
+        """
+        write a section of parameters to file
+        :param fid: File object to write to
+        :type fid:
+        :param names: which parameter names to write to file
+        :type names:
+        :param title: title of section
+        :type title: str
+        :param separator: section separator, written at start of section
+        :type separator: str
+        :return:
+        :rtype:
+        """
+        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):
+    '''
+    FilterOptions is a parameter object type providing Butterworth filter
+    option parameter for PyLoT. Its easy to access properties helps to manage
+    file based as well as parameter manipulation within the GUI.
+
+    :type filtertype: str, optional
+    :param filtertype: String containing the desired filtertype For information
+    about the supported filter types see _`Supported Filter` section .
+
+    :type freq: list, optional
+    :param freq: list of float(s) describing the cutoff limits of the filter
+
+    :type order: int, optional
+    :param order: Integer value describing the order of the desired Butterworth
+    filter.
+
+    .. rubric:: _`Supported Filter`
+
+        ``'bandpass'``
+            Butterworth-Bandpass
+
+        ``'bandstop'``
+            Butterworth-Bandstop
+
+        ``'lowpass'``
+            Butterworth-Lowpass
+
+        ``'highpass'``
+            Butterworth-Highpass
+    '''
+
+    def __init__(self, filtertype='bandpass', freq=[2., 5.], order=3,
+                 **kwargs):
+        self._order = order
+        self._filtertype = filtertype
+        self._freq = freq
+
+    def __str__(self):
+        hrs = '''\n\tFilter parameter:\n
+        Type:\t\t{ftype}\n
+        Frequencies:\t{freq}\n
+        Order:\t\t{order}\n
+        '''.format(ftype=self.getFilterType(),
+                   freq=self.getFreq(),
+                   order=self.getOrder())
+        return hrs
+
+    def __nonzero__(self):
+        return bool(self.getFilterType())
+
+    def parseFilterOptions(self):
+        if self:
+            robject = {'type': self.getFilterType(),
+                       'corners': self.getOrder(),
+                       'zerophase': False}
+            if not self.getFilterType() in ['highpass', 'lowpass']:
+                robject['freqmin'] = self.getFreq()[0]
+                robject['freqmax'] = self.getFreq()[1]
+            elif self.getFilterType() == 'highpass':
+                robject['freq'] = self.getFreq()[0]
+            elif self.getFilterType() == 'lowpass':
+                robject['freq'] = self.getFreq()[1]
+            return robject
+        return None
+
+    def getFreq(self):
+        return self.__getattribute__('_freq')
+
+    def setFreq(self, freq):
+        self.__setattr__('_freq', freq)
+
+    def getOrder(self):
+        return self.__getattribute__('_order')
+
+    def setOrder(self, order):
+        self.__setattr__('_order', order)
+
+    def getFilterType(self):
+        return self.__getattribute__('_filtertype')
+
+    def setFilterType(self, filtertype):
+        self.__setattr__('_filtertype', filtertype)

pylot/core/io/location.py

@@ -0,0 +1,220 @@
+from obspy import UTCDateTime
+from obspy.core import event as ope
+
+from pylot.core.util.utils import get_login, get_hash
+
+
+def create_amplitude(pickID, amp, unit, category, cinfo):
+    '''
+
+    :param pickID:
+    :param amp:
+    :param unit:
+    :param category:
+    :param cinfo:
+    :return:
+    '''
+    amplitude = ope.Amplitude()
+    amplitude.creation_info = cinfo
+    amplitude.generic_amplitude = amp
+    amplitude.unit = ope.AmplitudeUnit(unit)
+    amplitude.type = ope.AmplitudeCategory(category)
+    amplitude.pick_id = pickID
+    return amplitude
+
+
+def create_arrival(pickresID, cinfo, phase, azimuth=None, dist=None):
+    '''
+    create_arrival - function to create an Obspy Arrival
+
+    :param pickresID: Resource identifier of the created pick
+    :type pickresID: :class: `~obspy.core.event.ResourceIdentifier` object
+    :param cinfo: An ObsPy :class: `~obspy.core.event.CreationInfo` object
+    holding information on the creation of the returned object
+    :type cinfo: :class: `~obspy.core.event.CreationInfo` object
+    :param phase: name of the arrivals seismic phase
+    :type phase: str
+    :param azimuth: azimuth between source and receiver
+    :type azimuth: float or int, optional
+    :param dist: distance between source and receiver
+    :type dist: float or int, optional
+    :return: An ObsPy :class: `~obspy.core.event.Arrival` object
+    '''
+    arrival = ope.Arrival()
+    arrival.creation_info = cinfo
+    arrival.pick_id = pickresID
+    arrival.phase = phase
+    if azimuth is not None:
+        arrival.azimuth = float(azimuth) if azimuth > -180 else azimuth + 360.
+    else:
+        arrival.azimuth = azimuth
+    arrival.distance = dist
+    return arrival
+
+
+def create_creation_info(agency_id=None, creation_time=None, author=None):
+    '''
+    get creation info of obspy event
+    :param agency_id:
+    :param creation_time:
+    :param author:
+    :return:
+    '''
+    if author is None:
+        author = get_login()
+    if creation_time is None:
+        creation_time = UTCDateTime()
+    return ope.CreationInfo(agency_id=agency_id, author=author,
+                            creation_time=creation_time)
+
+
+def create_event(origintime, cinfo, originloc=None, etype='earthquake',
+                 resID=None, authority_id=None):
+    '''
+    create_event - funtion to create an ObsPy Event
+
+    :param origintime: the events origintime
+    :type origintime: :class: `~obspy.core.utcdatetime.UTCDateTime` object
+    :param cinfo: An ObsPy :class: `~obspy.core.event.CreationInfo` object
+        holding information on the creation of the returned object
+    :type cinfo: :class: `~obspy.core.event.CreationInfo` object
+    :param originloc: tuple containing the location of the origin
+        (LAT, LON, DEP) affiliated with the event which is created
+    :type originloc: tuple, list
+    :param etype: Event type str object. converted via ObsPy to a valid event
+        type string.
+    :type etype: str
+    :param resID: Resource identifier of the created event
+    :type resID: :class: `~obspy.core.event.ResourceIdentifier` object, str
+    :param authority_id: name of the institution carrying out the processing
+    :type authority_id: str
+    :return: An ObsPy :class: `~obspy.core.event.Event` object
+    '''
+
+    if originloc is not None:
+        o = create_origin(origintime, cinfo,
+                          originloc[0], originloc[1], originloc[2])
+    else:
+        o = None
+    if not resID:
+        resID = create_resourceID(origintime, etype, authority_id)
+    elif isinstance(resID, str):
+        resID = create_resourceID(origintime, etype, authority_id, resID)
+    elif not isinstance(resID, ope.ResourceIdentifier):
+        raise TypeError("unsupported type(resID) for resource identifier "
+                        "generation: %s" % type(resID))
+    event = ope.Event(resource_id=resID)
+    event.creation_info = cinfo
+    event.event_type = etype
+    if o:
+        event.origins = [o]
+    return event
+
+
+def create_magnitude(originID, cinfo):
+    '''
+    create_magnitude - function to create an ObsPy Magnitude object
+    :param originID:
+    :type originID:
+    :param cinfo:
+    :type cinfo:
+    :return:
+    '''
+    magnitude = ope.Magnitude()
+    magnitude.creation_info = cinfo
+    magnitude.origin_id = originID
+    return magnitude
+
+
+def create_origin(origintime, cinfo, latitude, longitude, depth):
+    '''
+    create_origin - function to create an ObsPy Origin
+    :param origintime: the origins time of occurence
+    :type origintime: :class: `~obspy.core.utcdatetime.UTCDateTime` object
+    :param cinfo:
+    :type cinfo:
+    :param latitude: latitude in decimal degree of the origins location
+    :type latitude: float
+    :param longitude: longitude in decimal degree of the origins location
+    :type longitude: float
+    :param depth: hypocentral depth of the origin
+    :type depth: float
+    :return: An ObsPy :class: `~obspy.core.event.Origin` object
+    '''
+
+    assert isinstance(origintime, UTCDateTime), "origintime has to be " \
+                                                "a UTCDateTime object, but " \
+                                                "actually is of type " \
+                                                "'%s'" % type(origintime)
+
+    origin = ope.Origin()
+    origin.time = origintime
+    origin.creation_info = cinfo
+    origin.latitude = latitude
+    origin.longitude = longitude
+    origin.depth = depth
+    return origin
+
+
+def create_pick(origintime, picknum, picktime, eventnum, cinfo, phase, station,
+                wfseedstr, authority_id):
+    '''
+    create_pick - function to create an ObsPy Pick
+
+    :param origintime:
+    :type origintime:
+    :param picknum: number of the created pick
+    :type picknum: int
+    :param picktime:
+    :type picktime:
+    :param eventnum: human-readable event identifier
+    :type eventnum: str
+    :param cinfo: An ObsPy :class: `~obspy.core.event.CreationInfo` object
+        holding information on the creation of the returned object
+    :type cinfo: :class: `~obspy.core.event.CreationInfo` object
+    :param phase: name of the arrivals seismic phase
+    :type phase: str
+    :param station: name of the station at which the seismic phase has been
+        picked
+    :type station: str
+    :param wfseedstr: A SEED formatted string of the form
+        network.station.location.channel in order to set a referenced waveform
+    :type wfseedstr: str, SEED formatted
+    :param authority_id: name of the institution carrying out the processing
+    :type authority_id: str
+    :return: An ObsPy :class: `~obspy.core.event.Pick` object
+    '''
+    pickID = eventnum + '_' + station.strip() + '/{0:03d}'.format(picknum)
+    pickresID = create_resourceID(origintime, 'pick', authority_id, pickID)
+    pick = ope.Pick()
+    pick.resource_id = pickresID
+    pick.time = picktime
+    pick.creation_info = cinfo
+    pick.phase_hint = phase
+    pick.waveform_id = ope.ResourceIdentifier(id=wfseedstr, prefix='file:/')
+    return pick
+
+
+def create_resourceID(timetohash, restype, authority_id=None, hrstr=None):
+    '''
+    create unique resource id
+    :param timetohash: event origin time to hash
+    :type timetohash: class: `~obspy.core.utcdatetime.UTCDateTime` object
+    :param restype: type of the resource, e.g. 'orig', 'earthquake' ...
+    :type restype: str
+    :param authority_id: name of the institution carrying out the processing
+    :type authority_id: str, optional
+    :param hrstr:
+    :type hrstr:
+    :return:
+    '''
+    assert isinstance(timetohash, UTCDateTime), "'timetohash' is not an ObsPy" \
+                                                "UTCDateTime object"
+    hid = get_hash(timetohash)
+    if hrstr is None:
+        resID = ope.ResourceIdentifier(restype + '/' + hid[0:6])
+    else:
+        resID = ope.ResourceIdentifier(restype + '/' + hrstr)
+    if authority_id is not None:
+        resID.convertIDToQuakeMLURI(authority_id=authority_id)
+    return resID