[change] corrected for required versions

refactor: remove unused methods
refactor: restructure data objects
2024-08-30 15:01:28 +02:00 · 2024-08-30 15:01:28 +02:00 · 2024-08-30 15:01:18 +02:00 · 2024-08-30 15:00:44 +02:00 · 2024-08-30 15:00:44 +02:00 · 2024-08-30 14:59:28 +02:00
57 changed files with 114768 additions and 112548 deletions
@@ -1,36 +1,54 @@
 # PyLoT
-version: 0.2
+version: 0.3
 The Python picking and Localisation Tool
-This python library contains a graphical user interfaces for picking
+This python library contains a graphical user interfaces for picking seismic phases. This software needs [ObsPy][ObsPy]
-seismic phases. This software needs [ObsPy][ObsPy]
+and the PySide2 Qt5 bindings for python to be installed first.
 and the PySide Qt4 bindings for python to be installed first.
-PILOT has originally been developed in Mathworks' MatLab. In order to
+PILOT has originally been developed in Mathworks' MatLab. In order to distribute PILOT without facing portability
-distribute PILOT without facing portability problems, it has been decided
+problems, it has been decided to redevelop the software package in Python. The great work of the ObsPy group allows easy
-to redevelop the software package in Python. The great work of the ObsPy
+handling of a bunch of seismic data and PyLoT will benefit a lot compared to the former MatLab version.
 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.
+At the moment there is no automatic installation procedure available for PyLoT. Best way to install is to clone the
-Best way to install is to clone the repository and add the path to your Python path.
+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 2 or 3
+- Python 3
 - obspy
 - pyside2
 - pyqtgraph
 - cartopy
 (the following are already dependencies of the above packages):
 - scipy
 - numpy
- matplotlib
+- matplotlib <= 3.3.x
 - obspy
 - pyside
 #### Some handwork:
@@ -53,7 +71,8 @@ In the next step you have to copy some files to this directory:
    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
+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/
@@ -61,7 +80,6 @@ You may need to do some modifications to these files. Especially folder names sh
 PyLoT has been tested on Mac OSX (10.11), Debian Linux 8 and on Windows 10.
 ## Release notes
 #### Features:
@@ -77,20 +95,17 @@ PyLoT has been tested on Mac OSX (10.11), Debian Linux 8 and on Windows 10.
 #### Known issues:
 - Sometimes an error might occur when using Qt
 We hope to solve these with the next release.
 ## Staff
-Original author(s): L. Kueperkoch, S. Wehling-Benatelli, M. Bischoff (PILOT)
+Original author(s): M. Rische, S. Wehling-Benatelli, L. Kueperkoch, M. Bischoff (PILOT)
-Developer(s): S. Wehling-Benatelli, L. Kueperkoch, K. Olbert, M. Bischoff,
+Developer(s): S. Wehling-Benatelli, M. Paffrath, L. Kueperkoch, K. Olbert, M. Bischoff, C. Wollin, M. Rische, D. Arnold, K. Cökerim, S. Zimmermann
              C. Wollin, M. Rische, M. Paffrath
 Others: A. Bruestle, T. Meier, W. Friederich
 [ObsPy]: http://github.com/obspy/obspy/wiki
-September 2017
+April 2022
@@ -8,6 +8,7 @@ import datetime
 import glob
 import os
 import traceback
 from obspy import read_events
 from obspy.core.event import ResourceIdentifier
@@ -27,7 +28,7 @@ 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, \
+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
@@ -90,9 +91,9 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even
                                                              sp=sp_info)
    print(splash)
-    parameter = get_None(parameter)
+    parameter = get_none(parameter)
-    inputfile = get_None(inputfile)
+    inputfile = get_none(inputfile)
-    eventid = get_None(eventid)
+    eventid = get_none(eventid)
    fig_dict = None
    fig_dict_wadatijack = None
@@ -118,13 +119,9 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even
            obspyDMT_wfpath = input_dict['obspyDMT_wfpath']
    if not parameter:
-        if inputfile:
+        if not inputfile:
            print('Using default input parameter')
        parameter = PylotParameter(inputfile)
            # iplot = parameter['iplot']
        else:
            infile = os.path.join(os.path.expanduser('~'), '.pylot', 'pylot.in')
            print('Using default input file {}'.format(infile))
            parameter = PylotParameter(infile)
    else:
        if not type(parameter) == PylotParameter:
            print('Wrong input type for parameter: {}'.format(type(parameter)))
@@ -153,7 +150,7 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even
        datastructure.setExpandFields(exf)
        # check if default location routine NLLoc is available and all stations are used
-        if get_None(parameter['nllocbin']) and station == 'all':
+        if get_none(parameter['nllocbin']) and station == 'all':
            locflag = 1
            # get NLLoc-root path
            nllocroot = parameter.get('nllocroot')
@@ -246,7 +243,7 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even
                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, '*')))
+                data.set_wf_data(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
@@ -261,7 +258,7 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even
                                                      now.minute)
                    parameter.setParam(eventID=eventID)
            else:
-                data.setWFData(fnames)
+                data.set_wf_data(fnames)
                eventpath = events[0]
                # now = datetime.datetime.now()
@@ -271,13 +268,13 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even
                #                               now.hour,
                #                               now.minute)
                parameter.setParam(eventID=eventid)
-            wfdat = data.getWFData()  # all available streams
+            wfdat = data.get_wf_data()  # 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)
+            # 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)
@@ -3,8 +3,10 @@
 #$ -l low
 #$ -cwd
 #$ -pe smp 40
-#$ -l mem=2G
+##$ -l mem=3G
-#$ -l h_vmem=2G
+#$ -l h_vmem=6G
 #$ -l os=*stretch
-python ./autoPyLoT.py -i /home/marcel/.pylot/pylot_alparray_mantle_corr_stack_0.03-0.5.in -dmt processed -c $NSLOTS
+conda activate pylot_311
 python ./autoPyLoT.py -i /home/marcel/.pylot/pylot_adriaarray.in -c 20 -dmt processed
@@ -44,15 +44,17 @@ This section describes how to use PyLoT graphically to view waveforms and create
 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)
+[//]: <> (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.
+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">
@@ -61,24 +63,21 @@ Add trace data by [loading a project](#projects-and-events) or by [adding event
 ### 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.
+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.
+Above the traces the currently displayed event can be selected. In the bottom bar information about the trace under the
-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 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
+Hold right mouse button and Direction | Result --- | --- Move the mouse up | Increase amplitude scale Move the mouse
-Direction | Result
+down | Decrease amplitude scale Move the mouse right | Increase time scale Move the mouse left | Decrease time scale
 --- | ---
 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.
@@ -108,21 +107,31 @@ Press right mouse button and click "View All" from the context menu to reset the
 ### 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 array map will display a color diagram to allow a visual check of the consistency of picks across multiple stations.
-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).
+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.
+Above the Array Map the picks that are used to create the map can be customized. The phase of picks that should be used
-The phase of picks that should be used can be selected, which allows checking the consistency of the P- and S-phase separately.
+can be selected, which allows checking the consistency of the P- and S-phase separately. Additionally the pick type can
-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.
+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.*
+*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.
+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.
+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">
@@ -144,22 +153,32 @@ The eventlist displays event parameters. The displayed parameters are saved in t
 ### 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.
+PyLoT uses projects to categorize different seismic data. A project consists of one or multiple events. Events contain
-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.
+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.
+  ``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.   
+* All automatic and manual picks should be in an ``.xml`` file in their event folder. PyLoT saves picks in this file.
-Picks are saved in a file with the same filename as the event folder with ``PyLoT_`` prepended.
+  This file does not have to be added manually unless there are picks to be imported. The format used to save picks is
-* The file ``notes.txt`` is used for saving analysts comments. Everything saved here will be displayed in the 'Notes' column of the eventlist.
+  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.   
+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.
@@ -181,36 +200,50 @@ The meaning of the header entries is:
 ### 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. 
+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.
+Save the current project from the menu with File->Save project or File->Save project as. PyLoT uses ``.plp`` files to
-PyLoT uses ``.plp`` files to save project information. This file format is not interchangeable between different versions of Python interpreters.
+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.
+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.
+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.
+* 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).
+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. 
+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">
@@ -243,105 +276,167 @@ Access the Filter options by pressing Ctrl+f on the Waveform plot or by the menu
 <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).  
+Here you are able to select filter type, order and frequencies for the P and S pick separately. These settings are used
-A green value automatic value means the automatic and manual filter parameter is configured the same, red means they are configured differently.
+in the GUI for displaying the filtered waveform data and during manual picking. The values used by PyLoT for automatic
-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).
+picking are displayed next to the manual values. They can be changed in the [Tune Autopicker dialog](#tuning).  
-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.
+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]``.     
+After the creation of manual picks they can either be saved in the project file (
-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. 
+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.
+To import previously saved picks press
-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. 
+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. 
+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
+
 - 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.  
+For automatic picking PyLoT discerns between tune and test events, which the user has to set as such. Tune events are
-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.
+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. 
+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.
+3. To pick the currently displayed trace, click
-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.
+   the <img src=images/gui/tuning/autopick_trace_button.png alt="Pick trace button" title="Autopick trace button" height=16>
-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.
+   button.
-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. 
+4. These tabs are used to select the current view. __Traces Plot__ contains a plot of the stations traces, where manual
-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.   
+   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).
+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.
+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 jackknife test in PyLoT checks the consistency of automatically determined P-picks by checking the statistical
-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.   
+variance of the picks. The variance of all P-picks is calculated and compared to the variance of subsets, in which one
-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).
+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.
+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 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.
+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.
+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.*
+*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. 
+Every pick in PyLoT consists of an earliest possible, latest possible and most likely onset time. The earliest and
-The earliest and latest possible onset time characterize the uncertainty of a pick. 
+latest possible onset time characterize the uncertainty of a pick. This approach is described in Diel, Kissling and
-This approach is described in Diel, Kissling and Bormann (2012) - Tutorial for consistent phase picking at local to regional distances. 
+Bormann (2012) - Tutorial for consistent phase picking at local to regional distances. These times are represented as a
-These times are represented as a Probability Density Function (PDF) for every pick. 
+Probability Density Function (PDF) for every pick. The PDF is implemented as two exponential distributions around the
-The PDF is implemented as two exponential distributions around the most likely onset as the expected value. 
+most likely onset as the expected value.
-To compare two single picks, their PDFs are cross correlated to create a new PDF. 
+To compare two single picks, their PDFs are cross correlated to create a new PDF. This corresponds to the subtraction of
-This corresponds to the subtraction of the automatic pick from the manual pick.
+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.*  
+*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 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 difference is implemented as a cross correlation between the two PDFs. and results in a new PDF, the comparison
- *The expected value of the comparison PDF corresponds to the time distance between the automatic and manual picks most likely onset.*
+PDF.*
- *The standard deviation corresponds to the combined uncertainty.*
+*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.
+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">
@@ -350,11 +445,13 @@ To compare the automatic and manual picks between multiple stations of an event,
 *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.* 
+*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 expected values are largely negative, meaning that the algorithm tends to pick earlier than the analyst with the
-*The number of samples mentioned in the plots legends is the amount of stations that have an automatic and a manual P pick.*
+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
@@ -367,7 +464,11 @@ 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).
+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.
+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.
@@ -8,12 +8,18 @@ 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.    |
+| *P Start*, *P
-| *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. |
+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.    |
-| *Bandpass Z1*       | Filter settings for Butterworth bandpass applied to vertical trace for calculation of initial P pick.                                                                                                                   |
+| *S Start*, *S
-| *Bandpass Z2*       | Filter settings for Butterworth bandpass applied to vertical trace for calculation of precise P pick.                                                                                                                   |
+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 H1*       | Filter settings for Butterworth bandpass applied to horizontal traces for calculation of initial S pick.                                                                                                                |
+| *Bandpass
-| *Bandpass H2*       | Filter settings for Butterworth bandpass applied to horizontal traces for calculation of precise S pick.                                                                                                                |
+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
@@ -21,15 +27,24 @@ 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.       |
+tLTA*       | Size of gliding LTA window in seconds used for calculation of HOS-CF.                                                        |
-| *AICtsmooth* | Average of samples in this time window will be used for smoothing of the AIC-CF.                                             |
+| *pickwin
-| *checkwinP*  | Time in front of the global maximum of the HOS-CF in which to search for a second local extrema.                             |
+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.       |
-| *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.                                       |
+AICtsmooth* | Average of samples in this time window will be used for smoothing of the AIC-CF.                                             |
-| *tnoise*     | Time window in seconds in front of initial P pick used for determining noise amplitude.                                      |
+| *
-| *tsafetey*   | Time in seconds between *tsignal* and *tnoise*.                                                                              |
+checkwinP*  | Time in front of the global maximum of the HOS-CF in which to search for a second local extrema.                             |
-| *tslope*     | Time window in seconds after initial P pick in which the slope of the onset is calculated.                                   |
+| *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
@@ -37,16 +52,26 @@ 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.                                      |
+tdet1h*      | Length of time window in seconds in which AR params of the waveform are determined.                                          |
-| *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.                          |
+tpred1h*     | Length of time window in seconds in which the waveform is predicted using the AR model.                                      |
-| *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*. |
+AICtsmoothS* | Average of samples in this time window is used for smoothing the AIC-CF.                                                     |
-| *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.                                      |
+pickwinS*    | Time window in which the minimum in the AIC-CF in front of the maximum in the ARH-CF is determined.                          |
-| *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.                                   |
+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
@@ -54,9 +79,13 @@ 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*.                                   |
+| *Precalcwin* | Time window in seconds for recalculation of the HOS-CF. The new CF will be two times the size of *
-| *tsmoothP*   | Average of samples in this time window will be used for smoothing the second HOS-CF.                                                                                                                                    |
+Precalcwin*, since it will be calculated from the initial pick to +/- *Precalcwin*.                                   |
-| *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*). |
+| *
 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
@@ -64,12 +93,19 @@ 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.                                                                                                                                      |
+tdet2h*     | Time window for determination of AR coefficients.                                                                                                                                                                       |
-| *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.                                                                                                                                    |
+tpred2h*    | Time window in which the waveform is predicted using the determined AR parameters.                                                                                                                                      |
-| *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*). |
+| *Srecalcwin* | Time window for recalculation of ARH-CF. New CF will be calculated from initial pick +/- *
-| *pickwinS*   | Time window around initial pick in which to look for a precise 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
@@ -77,15 +113,27 @@ 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.                                                                                                                                                                                                                 |
+minAICPslope*                             | Initial P picks with a slope lower than this value will be discared.                                                                                                                                                                                                           |
-| *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.                                                                                                                                                                                                                 |
+minAICPSNR*                               | Initial P 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. |
+minAICSslope*                             | Initial S picks with a slope lower than this value will be discarded.                                                                                                                                                                                                          |
-| *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.                                                                                                                                                                                                  |
+minAICSSNR*                               | Initial S picks with a SNR below this value will be discarded.                                                                                                                                                                                                                 |
-| *wdttolerance*                             | Maximum allowed deviation of S onset times from the line during the Wadati test. Value in seconds.                                                                                                                                                                             |
+| *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
@@ -93,7 +141,10 @@ 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.                                                                           |
+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.                                                                           |
-| *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. |
+| *
 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. |
@@ -1,118 +1,14 @@
-name: pylot_py35
+name: pylot_38
 channels:
  - conda-forge
  - defaults
 dependencies:
-  - _libgcc_mutex=0.1=conda_forge
+  - cartopy=0.20.2
-  - _openmp_mutex=4.5=1_gnu
+  - matplotlib-base=3.3.4
-  - brotlipy=0.7.0=py36h8f6f2f9_1001
+  - numpy=1.22.3
-  - c-ares=1.17.1=h7f98852_1
+  - obspy=1.3.0
-  - ca-certificates=2021.5.30=ha878542_0
+  - pyqtgraph=0.12.4
-  - cartopy=0.18.0=py36h104b3a8_13
+  - pyside2>=5.13.2
-  - certifi=2021.5.30=py36h5fab9bb_0
+  - python=3.8.12
-  - cffi=1.14.5=py36hc120d54_0
+  - qt>=5.12.9
-  - chardet=4.0.0=py36h5fab9bb_1
+  - scipy=1.8.0
  - cryptography=3.4.6=py36hb60f036_0
  - cycler=0.10.0=py_2
  - dbus=1.13.6=hfdff14a_1
  - decorator=4.4.2=py_0
  - expat=2.2.10=h9c3ff4c_0
  - fontconfig=2.13.1=hba837de_1004
  - freetype=2.10.4=h0708190_1
  - future=0.18.2=py36h5fab9bb_3
  - geos=3.9.1=h9c3ff4c_2
  - gettext=0.19.8.1=h0b5b191_1005
  - glib=2.68.0=h9c3ff4c_1
  - glib-tools=2.68.0=h9c3ff4c_1
  - greenlet=1.0.0=py36hc4f0c31_0
  - gst-plugins-base=1.18.4=h29181c9_0
  - gstreamer=1.18.4=h76c114f_0
  - icu=68.1=h58526e2_0
  - idna=2.10=pyh9f0ad1d_0
  - importlib-metadata=3.7.3=py36h5fab9bb_0
  - jpeg=9d=h36c2ea0_0
  - kiwisolver=1.3.1=py36h605e78d_1
  - krb5=1.17.2=h926e7f8_0
  - lcms2=2.12=hddcbb42_0
  - ld_impl_linux-64=2.35.1=hea4e1c9_2
  - libblas=3.9.0=8_openblas
  - libcblas=3.9.0=8_openblas
  - libclang=11.1.0=default_ha53f305_0
  - libcurl=7.75.0=hc4aaa36_0
  - libedit=3.1.20191231=he28a2e2_2
  - libev=4.33=h516909a_1
  - libevent=2.1.10=hcdb4288_3
  - libffi=3.3=h58526e2_2
  - libgcc-ng=9.3.0=h2828fa1_18
  - libgfortran-ng=9.3.0=hff62375_18
  - libgfortran5=9.3.0=hff62375_18
  - libglib=2.68.0=h3e27bee_1
  - libgomp=9.3.0=h2828fa1_18
  - libiconv=1.16=h516909a_0
  - liblapack=3.9.0=8_openblas
  - libllvm11=11.1.0=hf817b99_0
  - libnghttp2=1.43.0=h812cca2_0
  - libopenblas=0.3.12=pthreads_h4812303_1
  - libpng=1.6.37=h21135ba_2
  - libpq=13.1=hfd2b0eb_2
  - libssh2=1.9.0=ha56f1ee_6
  - libstdcxx-ng=9.3.0=h6de172a_18
  - libtiff=4.2.0=hdc55705_0
  - libuuid=2.32.1=h7f98852_1000
  - libwebp-base=1.2.0=h7f98852_2
  - libxcb=1.13=h7f98852_1003
  - libxkbcommon=1.0.3=he3ba5ed_0
  - libxml2=2.9.10=h72842e0_3
  - libxslt=1.1.33=h15afd5d_2
  - lxml=4.6.2=py36h04a5ba7_1
  - lz4-c=1.9.3=h9c3ff4c_0
  - matplotlib-base=3.3.4=py36hd391965_0
  - mysql-common=8.0.23=ha770c72_1
  - mysql-libs=8.0.23=h935591d_1
  - ncurses=6.2=h58526e2_4
  - nspr=4.30=h9c3ff4c_0
  - nss=3.63=hb5efdd6_0
  - numpy=1.19.5=py36h2aa4a07_1
  - obspy=1.2.2=py36h785e9b2_0
  - olefile=0.46=pyh9f0ad1d_1
  - openssl=1.1.1k=h7f98852_0
  - pandas=1.1.5=py36h284efc9_0
  - pcre=8.44=he1b5a44_0
  - pillow=8.1.2=py36ha6010c0_0
  - pip=21.0.1=pyhd8ed1ab_0
  - proj=7.2.0=h277dcde_2
  - pthread-stubs=0.4=h36c2ea0_1001
  - pycparser=2.20=pyh9f0ad1d_2
  - pyopenssl=20.0.1=pyhd8ed1ab_0
  - pyparsing=2.4.7=pyh9f0ad1d_0
  - pyqt5-sip=4.19.18=py36hc4f0c31_7
  - pyqtgraph=0.11.1=pyhd3deb0d_0
  - pyshp=2.1.3=pyh44b312d_0
  - pyside2=5.13.2=py36h6b97533_4
  - pysocks=1.7.1=py36h5fab9bb_3
  - python=3.6.13=hffdb5ce_0_cpython
  - python-dateutil=2.8.1=py_0
  - python_abi=3.6=1_cp36m
  - pytz=2021.1=pyhd8ed1ab_0
  - qt=5.12.9=hda022c4_4
  - qtpy=1.9.0=py_0
  - readline=8.0=he28a2e2_2
  - requests=2.25.1=pyhd3deb0d_0
  - scipy=1.5.3=py36h9e8f40b_0
  - setuptools=49.6.0=py36h5fab9bb_3
  - shapely=1.7.1=py36h93b233e_4
  - six=1.15.0=pyh9f0ad1d_0
  - sqlalchemy=1.4.2=py36h8f6f2f9_0
  - sqlite=3.34.0=h74cdb3f_0
  - tk=8.6.10=h21135ba_1
  - tornado=6.1=py36h8f6f2f9_1
  - typing_extensions=3.7.4.3=py_0
  - urllib3=1.26.4=pyhd8ed1ab_0
  - wheel=0.36.2=pyhd3deb0d_0
  - xorg-libxau=1.0.9=h7f98852_0
  - xorg-libxdmcp=1.1.3=h7f98852_0
  - xz=5.2.5=h516909a_1
  - zipp=3.4.1=pyhd8ed1ab_0
  - zlib=1.2.11=h516909a_1010
  - zstd=1.4.9=ha95c52a_0
 prefix:
@@ -144,6 +144,10 @@ class Magnitude(object):
                    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,
@@ -223,7 +227,7 @@ class LocalMagnitude(Magnitude):
                 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))
+            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]
@@ -414,6 +418,10 @@ class MomentMagnitude(Magnitude):
            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)
@@ -432,6 +440,40 @@ class MomentMagnitude(Magnitude):
            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):
    '''
@@ -594,15 +636,15 @@ def calcsourcespec(wfstream, onset, vp, delta, azimuth, incidence,
        # fft
        fny = freq / 2
-        #l = len(xdat) / freq
+        # l = len(xdat) / freq
        # number of fft bins after Bath
-        #n = freq * l
+        # 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))
+        # N = int(np.power(m, 2))
        y = dt * np.fft.fft(xdat, N)
-        Y = abs(y[: N / 2])
+        Y = abs(y[: int(N / 2)])
        L = (N - 1) / freq
        f = np.arange(0, fny, 1 / L)
@@ -679,6 +721,8 @@ def calcsourcespec(wfstream, onset, vp, delta, azimuth, incidence,
            plt.xlabel('Frequency [Hz]')
            plt.ylabel('Amplitude [m/Hz]')
            plt.grid()
            if iplot == 3:
                return w0, Fc, plt
            plt.show()
            try:
                input()
@@ -1,623 +1,69 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 import copy
 import os
-from obspy import read_events
+from dataclasses import dataclass, field
-from obspy.core import read, Stream, UTCDateTime
+from typing import List, Union
 from obspy.core.event import Event as ObsPyEvent
 from obspy.io.sac import SacIOError
-from PySide2.QtWidgets import QMessageBox
+from obspy import UTCDateTime
-import pylot.core.loc.velest as velest
+from pylot.core.io.event import EventData
-import pylot.core.loc.focmec as focmec
+from pylot.core.io.waveformdata import WaveformData
-import pylot.core.loc.hypodd as hypodd
+from pylot.core.util.dataprocessing import Metadata
 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, \
    check4gapsAndMerge, trim_station_components
-
+@dataclass
-class Data(object):
+class Data:
-    """
+    event_data: EventData = field(default_factory=EventData)
-    Data container with attributes wfdata holding ~obspy.core.stream.
+    waveform_data: WaveformData = field(default_factory=WaveformData)
-
+    metadata: Metadata = field(default_factory=Metadata)
-    :type parent: PySide2.QtWidgets.QWidget object, optional
+    _parent: Union[None, 'QtWidgets.QWidget'] = None
    :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.event_data = EventData(evtdata)
-            self.comp = parent.getComponent()
+        self.waveform_data = WaveformData()
        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 '
                                                  'implemeted.')
                    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)
+        return str(self.waveform_data.wfdata)
    def __add__(self, other):
-        assert isinstance(other, Data), "operands must be of same type 'Data'"
+        if not isinstance(other, Data):
-        rs_id = self.get_evt_data().get('resource_id')
+            raise TypeError("Operands must be of type 'Data'")
-        rs_id_other = other.get_evt_data().get('resource_id')
+        if self.event_data.is_new() and other.event_data.is_new():
        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:
+        elif other.event_data.is_new():
-            other.setNew()
+            new_picks = other.event_data.evtdata.picks
            old_picks = self.event_data.evtdata.picks
            old_picks.extend([pick for pick in new_picks if pick not in old_picks])
        elif self.event_data.is_new():
            return other + self
        elif self.event_data.get_id() == other.event_data.get_id():
            other.event_data.set_new()
            return self + other
        else:
-            raise ValueError("both Data objects have differing "
+            raise ValueError("Both Data objects have differing unique Event identifiers")
              "unique Event identifiers")
        return self
-    def getPicksStr(self):
+    def get_parent(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):
+    def filter_wf_data(self, **kwargs):
-        return self._new
+        self.waveform_data.wfdata.detrend('linear')
        self.waveform_data.wfdata.taper(0.02, type='cosine')
        self.waveform_data.wfdata.filter(**kwargs)
        self.waveform_data.dirty = True
-    def setNew(self):
+    def set_wf_data(self, fnames: List[str], fnames_alt: List[str] = None, check_rotated=False, metadata=None, tstart=0, tstop=0):
-        self._new = True
+        return self.waveform_data.load_waveforms(fnames, fnames_alt, check_rotated, metadata, tstart, tstop)
-    def getCutTimes(self):
+    def reset_wf_data(self):
-        """
+        self.waveform_data.reset()
        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):
+    def get_wf_data(self):
-        """
+        return self.waveform_data.wfdata
        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):
+    def rotate_wf_data(self):
-        ID = self.getID()
+        self.waveform_data.rotate_zne(self.metadata)
        # 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))
            if upperErrors:
                # check for pick uncertainties exceeding adjusted upper errors
                # Picks with larger uncertainties will not be saved in output file!
                for j in range(len(picks)):
                    for i in range(len(picks_copy)):
                        if picks_copy[i].phase_hint[0] == 'P':
                            if (picks_copy[i].time_errors['upper_uncertainty'] >= upperErrors[0]) or \
                                    (picks_copy[i].time_errors['uncertainty'] is None):
                                print("Uncertainty exceeds or equal adjusted upper time error!")
                                print("Adjusted uncertainty: {}".format(upperErrors[0]))
                                print("Pick uncertainty: {}".format(picks_copy[i].time_errors['uncertainty']))
                                print("{1} P-Pick of station {0} will not be saved in outputfile".format(
                                    picks_copy[i].waveform_id.station_code,
                                    picks_copy[i].method_id))
                                print("#")
                                del picks_copy[i]
                                break
                        if picks_copy[i].phase_hint[0] == 'S':
                            if (picks_copy[i].time_errors['upper_uncertainty'] >= upperErrors[1]) or \
                                    (picks_copy[i].time_errors['uncertainty'] is None):
                                print("Uncertainty exceeds or equal adjusted upper time error!")
                                print("Adjusted uncertainty: {}".format(upperErrors[1]))
                                print("Pick uncertainty: {}".format(picks_copy[i].time_errors['uncertainty']))
                                print("{1} S-Pick of station {0} will not be saved in outputfile".format(
                                    picks_copy[i].waveform_id.station_code,
                                    picks_copy[i].method_id))
                                print("#")
                                del picks_copy[i]
                                break
            if fnext == '.obs':
                try:
                    evtdata_copy.write(fnout + fnext, format=evtformat)
                    # write header afterwards
                    evid = str(evtdata_org.resource_id).split('/')[1]
                    header = '# EQEVENT:  Label: EQ%s  Loc:  X 0.00  Y 0.00  Z 10.00  OT 0.00 \n' % evid
                    nllocfile = open(fnout + fnext)
                    l = nllocfile.readlines()
                    # 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:
                    infile = os.path.join(os.path.expanduser('~'), '.pylot', 'pylot.in')
                    print('Using default input file {}'.format(infile))
                    parameter = PylotParameter(infile)
                    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:
                    infile = os.path.join(os.path.expanduser('~'), '.pylot', 'pylot.in')
                    print('Using default input file {}'.format(infile))
                    parameter = PylotParameter(infile)
                    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_syn=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
        :type fnames: list
        """
        self.wfdata = Stream()
        self.wforiginal = None
        self.wfsyn = Stream()
        if tstart == tstop:
            tstart = tstop = None
        self.tstart = tstart
        self.tstop = tstop
        # 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_syn is not None:
                self.appendWFData(fnames_syn, synthetic=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 = check4gapsAndMerge(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, synthetic=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()
        real_or_syn_data = {True: self.wfsyn,
                            False: self.wfdata}
        warnmsg = ''
        for fname in set(fnames):
            try:
                real_or_syn_data[synthetic] += read(fname, starttime=self.tstart, endtime=self.tstop)
            except TypeError:
                try:
                    real_or_syn_data[synthetic] += read(fname, format='GSE2', starttime=self.tstart, endtime=self.tstop)
                except Exception as e:
                    try:
                        real_or_syn_data[synthetic] += 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 getSynWFData(self):
        return self.wfsyn
    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):
@@ -802,22 +248,6 @@ class PilotDataStructure(GenericDataStructure):
        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:
@@ -0,0 +1,106 @@
 import copy
 from dataclasses import dataclass
 from typing import Union
 from obspy import read_events
 from obspy.core.event import Event as ObsPyEvent
@dataclass
 class EventData:
    evtdata: Union[ObsPyEvent, None] = None
    _new: bool = False
    def __init__(self, evtdata=None):
        self.set_event_data(evtdata)
    def set_event_data(self, evtdata):
        if isinstance(evtdata, ObsPyEvent):
            self.evtdata = evtdata
        elif isinstance(evtdata, dict):
            self.evtdata = self.read_pilot_event(**evtdata)
        elif isinstance(evtdata, str):
            self.evtdata = self.read_event_file(evtdata)
        else:
            self.set_new()
            self.evtdata = ObsPyEvent(picks=[])
    def read_event_file(self, evtdata: str) -> ObsPyEvent:
        try:
            cat = read_events(evtdata)
            if len(cat) != 1:
                raise ValueError(f'ambiguous event information for file: {evtdata}')
            return cat[0]
        except TypeError as e:
            self.handle_event_file_error(e, evtdata)
    def handle_event_file_error(self, e: TypeError, evtdata: str):
        if 'Unknown format for file' in str(e):
            if 'PHASES' in evtdata:
                picks = self.picksdict_from_pilot(evtdata)
                evtdata = ObsPyEvent(picks=self.picks_from_picksdict(picks))
            elif 'LOC' in evtdata:
                raise NotImplementedError('PILOT location information read support not yet implemented.')
            elif 'event.pkl' in evtdata:
                evtdata = self.qml_from_obspy_dmt(evtdata)
            else:
                raise e
        else:
            raise e
    def set_new(self):
        self._new = True
    def is_new(self) -> bool:
        return self._new
    def get_picks_str(self) -> str:
        return '\n'.join(str(pick) for pick in self.evtdata.picks)
    def replace_origin(self, event: ObsPyEvent, force_overwrite: bool = False):
        if self.evtdata.origins or force_overwrite:
            event.origins = self.evtdata.origins
    def replace_magnitude(self, event: ObsPyEvent, force_overwrite: bool = False):
        if self.evtdata.magnitudes or force_overwrite:
            event.magnitudes = self.evtdata.magnitudes
    def replace_picks(self, event: ObsPyEvent, picktype: str):
        checkflag = 1
        picks = event.picks
        for j, pick in reversed(list(enumerate(picks))):
            if picktype in str(pick.method_id.id):
                picks.pop(j)
                checkflag = 2
        if checkflag > 0:
            for pick in self.evtdata.picks:
                if picktype in str(pick.method_id.id):
                    picks.append(pick)
    def get_id(self) -> Union[str, None]:
        try:
            return self.evtdata.resource_id.id
        except:
            return None
    def apply_event_data(self, data, typ='pick'):
        if typ == 'pick':
            self.apply_picks(data)
        elif typ == 'event':
            self.apply_event(data)
    def apply_picks(self, picks):
        self.evtdata.picks = picks
    def apply_event(self, event: ObsPyEvent):
        if self.is_new():
            self.evtdata = event
        else:
            old_event = self.evtdata
            if old_event.resource_id == event.resource_id:
                picks = copy.deepcopy(old_event.picks)
                event = self.merge_picks(event, picks)
                old_event.update(event)
            else:
                print(f"WARNING: Mismatch in event resource id's: {old_event.resource_id} and {event.resource_id}")
@@ -8,14 +8,15 @@
   Edited for use in PyLoT
   JG, igem, 01/2022
 """
-import pdb
+
 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
 import glob
 """
 Creates an eventlist file summarizing all events found in a certain folder. Only called by pressing UI Button eventlis_xml_action
@@ -24,14 +25,15 @@ Creates an eventlist file summarizing all events found in a certain folder. Only
 :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')
+    evlistobj.write(
        'EventID      Date      To    Lat    Lon     EAST    NORTH  Dep  Ml  NoP  NoS RMS  errH  errZ  Gap \n')
    # data path
    dp = path + "/e*/*.xml"
@@ -52,7 +54,8 @@ def geteventlistfromxml(path, outpath):
            NoP = []
            NoS = []
        except IndexError:
-            print ('Insufficient data found for event (not localised): ' + names.split('/')[-1].split('_')[-1][:-4] + ' Skipping event for eventlist.' )
+            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)):
@@ -60,20 +63,22 @@ def geteventlistfromxml(path, outpath):
                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
+        # 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('/')[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, \
+        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))
+                                                                                                 Date, To, Lat, Lon,
-        print ('Adding Event ' + names.split('/')[-1].split('_')[-1][:-4]  + ' to eventlist')
+                                                                                                 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()
@@ -1,139 +0,0 @@
 #!/usr/bin/python
 # -*- coding: utf-8 -*-
 """
   Script to get onset uncertainties from Quakeml.xml files created by PyLoT.
   Uncertainties are tranformed into quality classes and visualized via histogram if desired.
   Ludger Küperkoch, BESTEC GmbH, 07/2017
   rev.: Ludger Küperkoch, igem, 10/2020
   Edited for usage in PyLoT: Jeldrik Gaal, igem, 01/2022
 """
 import argparse
 import numpy as np
 import matplotlib.pyplot as plt
 from obspy.core.event import read_events
 import glob
 def getQualitiesfromxml(path):
    # uncertainties 
    ErrorsP = [0.02, 0.04, 0.08, 0.16]
    ErrorsS = [0.04, 0.08, 0.16, 0.32]
    Pw0 = []
    Pw1 = []
    Pw2 = []
    Pw3 = []
    Pw4 = []
    Sw0 = []
    Sw1 = []
    Sw2 = []
    Sw3 = []
    Sw4 = []
    # 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 onset weights from {}".format(names))
        cat = read_events(names)
        arrivals = cat.events[0].picks
        for Pick in arrivals:
            if Pick.phase_hint[0] == 'P':
                if Pick.time_errors.uncertainty <= ErrorsP[0]:     
                    Pw0.append(Pick.time_errors.uncertainty)      
                elif Pick.time_errors.uncertainty > ErrorsP[0] and \
                     Pick.time_errors.uncertainty <= ErrorsP[1]:
                     Pw1.append(Pick.time_errors.uncertainty)      
                elif Pick.time_errors.uncertainty > ErrorsP[1] and \
                     Pick.time_errors.uncertainty <= ErrorsP[2]:
                     Pw2.append(Pick.time_errors.uncertainty)      
                elif Pick.time_errors.uncertainty > ErrorsP[2] and \
                     Pick.time_errors.uncertainty <= ErrorsP[3]:
                     Pw3.append(Pick.time_errors.uncertainty)      
                elif Pick.time_errors.uncertainty > ErrorsP[3]:
                     Pw4.append(Pick.time_errors.uncertainty)      
                else:
                    pass
            elif Pick.phase_hint[0] == 'S':
                if Pick.time_errors.uncertainty <= ErrorsS[0]:     
                     Sw0.append(Pick.time_errors.uncertainty)      
                elif Pick.time_errors.uncertainty > ErrorsS[0] and \
                     Pick.time_errors.uncertainty <= ErrorsS[1]:
                     Sw1.append(Pick.time_errors.uncertainty)      
                elif Pick.time_errors.uncertainty > ErrorsS[1] and \
                     Pick.time_errors.uncertainty <= ErrorsS[2]:
                     Sw2.append(Pick.time_errors.uncertainty)      
                elif Pick.time_errors.uncertainty > ErrorsS[2] and \
                     Pick.time_errors.uncertainty <= ErrorsS[3]:
                     Sw3.append(Pick.time_errors.uncertainty)      
                elif Pick.time_errors.uncertainty > ErrorsS[3]:
                     Sw4.append(Pick.time_errors.uncertainty)      
                else:
                    pass
            else:
                print("Phase hint not defined for picking!")
                pass
    # get percentage of weights
    numPweights = np.sum([len(Pw0), len(Pw1), len(Pw2), len(Pw3), len(Pw4)])
    numSweights = np.sum([len(Sw0), len(Sw1), len(Sw2), len(Sw3), len(Sw4)])
    try:
        P0perc = 100.0 / numPweights * len(Pw0)
    except:
        P0perc = 0
    try:
        P1perc = 100.0 / numPweights * len(Pw1)
    except:
        P1perc = 0
    try:
        P2perc = 100.0 / numPweights * len(Pw2)
    except:
        P2perc = 0
    try:
        P3perc = 100.0 / numPweights * len(Pw3)
    except:
        P3perc = 0
    try:
        P4perc = 100.0 / numPweights * len(Pw4)
    except:
        P4perc = 0
    try:
        S0perc = 100.0 / numSweights * len(Sw0)
    except:
        Soperc = 0
    try:
        S1perc = 100.0 / numSweights * len(Sw1)
    except:
        S1perc = 0
    try:
        S2perc = 100.0 / numSweights * len(Sw2)
    except:
        S2perc = 0
    try:
        S3perc = 100.0 / numSweights * len(Sw3)
    except:
        S3perc = 0
    try:
        S4perc = 100.0 / numSweights * len(Sw4)
    except:
        S4perc = 0
    weights = ('0', '1', '2', '3', '4')
    y_pos = np.arange(len(weights))
    width = 0.34
    p1, = plt.bar(0 - width, P0perc, width, color='black')
    p2, = plt.bar(0, S0perc, width, color='red')
    plt.bar(y_pos - width, [P0perc, P1perc, P2perc, P3perc, P4perc], width, color='black')
    plt.bar(y_pos, [S0perc, S1perc, S2perc, S3perc, S4perc], width, color='red')
    plt.ylabel('%')
    plt.xticks(y_pos, weights)
    plt.xlim([-0.5, 4.5])
    plt.xlabel('Qualities')
    plt.title('{0} P-Qualities, {1} S-Qualities'.format(numPweights, numSweights)) 
    plt.legend([p1, p2], ['P-Weights', 'S-Weights'])
    plt.show()
@@ -1,7 +1,7 @@
 from obspy import UTCDateTime
 from obspy.core import event as ope
-from pylot.core.util.utils import getLogin, getHash
+from pylot.core.util.utils import get_login, get_hash
 def create_amplitude(pickID, amp, unit, category, cinfo):
@@ -61,7 +61,7 @@ def create_creation_info(agency_id=None, creation_time=None, author=None):
    :return:
    '''
    if author is None:
-        author = getLogin()
+        author = get_login()
    if creation_time is None:
        creation_time = UTCDateTime()
    return ope.CreationInfo(agency_id=agency_id, author=author,
@@ -210,7 +210,7 @@ def create_resourceID(timetohash, restype, authority_id=None, hrstr=None):
    '''
    assert isinstance(timetohash, UTCDateTime), "'timetohash' is not an ObsPy" \
                                                "UTCDateTime object"
-    hid = getHash(timetohash)
+    hid = get_hash(timetohash)
    if hrstr is None:
        resID = ope.ResourceIdentifier(restype + '/' + hid[0:6])
    else:
@@ -0,0 +1,177 @@
 import os
 from pylot.core.util.event import Event
 class Project(object):
    '''
    Pickable class containing information of a PyLoT project, like event lists and file locations.
    '''
    # TODO: remove rootpath
    def __init__(self):
        self.eventlist = []
        self.location = None
        self.rootpath = None
        self.datapath = None
        self.dirty = False
        self.parameter = None
        self._table = None
    def add_eventlist(self, eventlist):
        '''
        Add events from an eventlist containing paths to event directories.
        Will skip existing paths.
        '''
        if len(eventlist) == 0:
            return
        for item in eventlist:
            event = Event(item)
            event.rootpath = self.parameter['rootpath']
            event.database = self.parameter['database']
            event.datapath = self.parameter['datapath']
            if not event.path in self.getPaths():
                self.eventlist.append(event)
                self.setDirty()
            else:
                print('Skipping event with path {}. Already part of project.'.format(event.path))
        self.eventlist.sort(key=lambda x: x.pylot_id)
        self.search_eventfile_info()
    def remove_event(self, event):
        self.eventlist.remove(event)
    def remove_event_by_id(self, eventID):
        for event in self.eventlist:
            if eventID in str(event.resource_id):
                self.remove_event(event)
                break
    def read_eventfile_info(self, filename, separator=','):
        '''
        Try to read event information from file (:param:filename) comparing specific event datetimes.
        File structure (each row): event, date, time, magnitude, latitude, longitude, depth
        separated by :param:separator each.
        '''
        with open(filename, 'r') as infile:
            for line in infile.readlines():
                eventID, date, time, mag, lat, lon, depth = line.split(separator)[:7]
                # skip first line
                try:
                    day, month, year = date.split('/')
                except:
                    continue
                year = int(year)
                # hardcoded, if year only consists of 2 digits (e.g. 16 instead of 2016)
                if year < 100:
                    year += 2000
                datetime = '{}-{}-{}T{}'.format(year, month, day, time)
                try:
                    datetime = UTCDateTime(datetime)
                except Exception as e:
                    print(e, datetime, filename)
                    continue
                for event in self.eventlist:
                    if eventID in str(event.resource_id) or eventID in event.origins:
                        if event.origins:
                            origin = event.origins[0]  # should have only one origin
                            if origin.time == datetime:
                                origin.latitude = float(lat)
                                origin.longitude = float(lon)
                                origin.depth = float(depth)
                            else:
                                continue
                        elif not event.origins:
                            origin = Origin(resource_id=event.resource_id,
                                            time=datetime, latitude=float(lat),
                                            longitude=float(lon), depth=float(depth))
                            event.origins.append(origin)
                        event.magnitudes.append(Magnitude(resource_id=event.resource_id,
                                                          mag=float(mag),
                                                          mag_type='M'))
                        break
    def search_eventfile_info(self):
        '''
        Search all datapaths in rootpath for filenames with given file extension fext
        and try to read event info from it
        '''
        datapaths = []
        fext = '.csv'
        for event in self.eventlist:
            if not event.datapath in datapaths:
                datapaths.append(event.datapath)
        for datapath in datapaths:
            # datapath = os.path.join(self.rootpath, datapath)
            if os.path.isdir(datapath):
                for filename in os.listdir(datapath):
                    filename = os.path.join(datapath, filename)
                    if os.path.isfile(filename) and filename.endswith(fext):
                        try:
                            self.read_eventfile_info(filename)
                        except Exception as e:
                            print('Failed on reading eventfile info from file {}: {}'.format(filename, e))
            else:
                print("Directory %s does not exist!" % datapath)
    def getPaths(self):
        '''
        Returns paths (eventlist) of all events saved in the project.
        '''
        paths = []
        for event in self.eventlist:
            paths.append(event.path)
        return paths
    def setDirty(self, value=True):
        self.dirty = value
    def getEventFromPath(self, path):
        '''
        Search for an event in the project by event path.
        '''
        for event in self.eventlist:
            if event.path == path:
                return event
    def save(self, filename=None):
        '''
        Save PyLoT Project to a file.
        Can be loaded by using project.load(filename).
        '''
        try:
            import pickle
        except ImportError:
            import _pickle as pickle
        if filename:
            self.location = filename
        else:
            filename = self.location
        table = self._table  # MP: see below
        try:
            outfile = open(filename, 'wb')
            self._table = []  # MP: Workaround as long as table cannot be saved as part of project
            pickle.dump(self, outfile, protocol=pickle.HIGHEST_PROTOCOL)
            self.setDirty(False)
            self._table = table  # MP: see above
            return True
        except Exception as e:
            print('Could not pickle PyLoT project. Reason: {}'.format(e))
            self.setDirty()
            self._table = table  # MP: see above
            return False
    @staticmethod
    def load(filename):
        '''
        Load project from filename.
        '''
        import pickle
        infile = open(filename, 'rb')
        project = pickle.load(infile)
        infile.close()
        project.location = filename
        print('Loaded %s' % filename)
        return project
@@ -0,0 +1,13 @@
 import os
 from typing import List
 def validate_filenames(filenames: List[str]) -> List[str]:
    """
    validate a list of filenames for file abundance
    :param filenames: list of possible filenames
    :type filenames: List[str]
    :return: list of valid filenames
    :rtype: List[str]
    """
    return [fn for fn in filenames if os.path.isfile(fn)]
@@ -0,0 +1,123 @@
 import logging
 from dataclasses import dataclass, field
 from typing import Union, List
 from obspy import Stream, read
 from obspy.io.sac import SacIOError
 from pylot.core.io.utils import validate_filenames
 from pylot.core.util.dataprocessing import Metadata
 from pylot.core.util.utils import get_stations, check_for_nan, check4rotated
@dataclass
 class WaveformData:
    wfdata: Stream = field(default_factory=Stream)
    wforiginal: Union[Stream, None] = None
    wf_alt: Stream = field(default_factory=Stream)
    dirty: bool = False
    def load_waveforms(self, fnames: List[str], fnames_alt: List[str] = None, check_rotated=False, metadata=None, tstart=0, tstop=0):
        fn_list = validate_filenames(fnames)
        if not fn_list:
            logging.warning('No valid filenames given for loading waveforms')
        else:
            self.clear()
            self.add_waveforms(fn_list)
        if fnames_alt is None:
            pass
        else:
            alt_fn_list = validate_filenames(fnames_alt)
            if not alt_fn_list:
                logging.warning('No valid alternative filenames given for loading waveforms')
            else:
                self.add_waveforms(alt_fn_list, alternative=True)
        if not fn_list and not alt_fn_list:
            logging.error('No filenames or alternative filenames given for loading waveforms')
            return False
        self.merge()
        self.replace_nan()
        if not check_rotated or not metadata:
            pass
        else:
            self.rotate_zne()
        self.trim_station_traces()
        self.wforiginal = self.wfdata.copy()
        self.dirty = False
        return True
    def add_waveforms(self, fnames: List[str], alternative: bool = False):
        data_stream = self.wf_alt if alternative else self.wfdata
        warnmsg = ''
        for fname in set(fnames):
            try:
                data_stream += read(fname)
            except TypeError:
                try:
                    data_stream += read(fname, format='GSE2')
                except Exception as e:
                    try:
                        data_stream += read(fname, format='SEGY')
                    except Exception as e:
                        warnmsg += f'{fname}\n{e}\n'
            except SacIOError as se:
                warnmsg += f'{fname}\n{se}\n'
        if warnmsg:
            print(f'WARNING in add_waveforms: unable to read waveform data\n{warnmsg}')
    def clear(self):
        self.wfdata = Stream()
        self.wforiginal = None
        self.wf_alt = Stream()
    def reset(self):
        """
        Resets the waveform data to its original state.
        """
        if self.wforiginal:
            self.wfdata = self.wforiginal.copy()
        else:
            self.wfdata = Stream()
        self.dirty = False
    def merge(self):
        """
        check for gaps in Stream and merge if gaps are found
        """
        gaps = self.wfdata.get_gaps()
        if gaps:
            merged = ['{}.{}.{}.{}'.format(*gap[:4]) for gap in gaps]
            self.wfdata.merge(method=1)
            logging.info('Merged the following stations because of gaps:')
            for station in merged:
                logging.info(station)
    def replace_nan(self):
        """
        Replace all NaNs in data with 0. (in place)
        """
        self.wfdata = check_for_nan(self.wfdata)
    def rotate_zne(self, metadata: Metadata = None):
        """
        Check all traces in stream for rotation. If a trace is not in ZNE rotation (last symbol of channel code is numeric) and the trace
        is in the metadata with azimuth and dip, rotate it to classical ZNE orientation.
        Rotating the traces requires them to be of the same length, so, all traces will be trimmed to a common length as a
        side effect.
        """
        self.wfdata = check4rotated(self.wfdata, metadata)
    def trim_station_traces(self):
        """
        trim data stream to common time window
        """
        for station in get_stations(self.wfdata):
            station_traces = self.wfdata.select(station=station)
            station_traces.trim(starttime=max([trace.stats.starttime for trace in station_traces]),
                                endtime=min([trace.stats.endtime for trace in station_traces]))
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 __version__ = _getVersionString()
@@ -25,4 +25,4 @@ def export(picks, fnout, parameter, eventinfo):
    :type eventinfo:  list object
    '''
    # write phases to FOCMEC-phase file
-    writephases(picks, 'FOCMEC', fnout, parameter, eventinfo)
+    write_phases(picks, 'FOCMEC', fnout, parameter, eventinfo)
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 __version__ = _getVersionString()
@@ -25,4 +25,4 @@ def export(picks, fnout, parameter, eventinfo):
    :type eventinfo:  list object
    '''
    # write phases to HASH-phase file
-    writephases(picks, 'HASH', fnout, parameter, eventinfo)
+    write_phases(picks, 'HASH', fnout, parameter, eventinfo)
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 __version__ = _getVersionString()
@@ -22,4 +22,4 @@ def export(picks, fnout, parameter):
    :type parameter:  object
    '''
    # write phases to HYPO71-phase file
-    writephases(picks, 'HYPO71', fnout, parameter)
+    write_phases(picks, 'HYPO71', fnout, parameter)
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 __version__ = _getVersionString()
@@ -25,4 +25,4 @@ def export(picks, fnout, parameter, eventinfo):
    :type eventinfo:  list object
    '''
    # write phases to hypoDD-phase file
-    writephases(picks, 'HYPODD', fnout, parameter, eventinfo)
+    write_phases(picks, 'HYPODD', fnout, parameter, eventinfo)
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 __version__ = _getVersionString()
@@ -22,4 +22,4 @@ def export(picks, fnout, parameter):
    :type parameter:  object
    '''
    # write phases to HYPOSAT-phase file
-    writephases(picks, 'HYPOSAT', fnout, parameter)
+    write_phases(picks, 'HYPOSAT', fnout, parameter)
@@ -4,11 +4,12 @@
 import glob
 import os
 import subprocess
 from obspy import read_events
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.utils import getPatternLine, runProgram
 from pylot.core.util.gui import which
 from pylot.core.util.utils import getPatternLine, runProgram
 from pylot.core.util.version import get_git_version as _getVersionString
 __version__ = _getVersionString()
@@ -33,7 +34,7 @@ def export(picks, fnout, parameter):
    :type parameter:  object
    '''
    # write phases to NLLoc-phase file
-    writephases(picks, 'NLLoc', fnout, parameter)
+    write_phases(picks, 'NLLoc', fnout, parameter)
 def modify_inputs(ctrfn, root, nllocoutn, phasefn, tttn):
@@ -81,8 +82,8 @@ def locate(fnin, parameter=None):
    :param fnin: external program name
    :return: None
    """
-    exe_path = which('NLLoc', parameter)
+    exe_path = os.path.join(parameter['nllocbin'], 'NLLoc')
-    if exe_path is None:
+    if not os.path.isfile(exe_path):
        raise NLLocError('NonLinLoc executable not found; check your '
                         'environment variables')
@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 __version__ = _getVersionString()
@@ -25,4 +25,4 @@ def export(picks, fnout, eventinfo, parameter=None):
    :type parameter:  object
    '''
    # write phases to VELEST-phase file
-    writephases(picks, 'VELEST', fnout, parameter, eventinfo)
+    write_phases(picks, 'VELEST', fnout, parameter, eventinfo)
@@ -9,21 +9,21 @@ function conglomerate utils.
 :author: MAGS2 EP3 working group / Ludger Kueperkoch
 """
 import copy
 import traceback
 import matplotlib.pyplot as plt
 import numpy as np
-import traceback
+from obspy import Trace
 from obspy.taup import TauPyModel
 from pylot.core.pick.charfuns import CharacteristicFunction
 from pylot.core.pick.charfuns import HOScf, AICcf, ARZcf, ARHcf, AR3Ccf
 from pylot.core.pick.picker import AICPicker, PragPicker
 from pylot.core.pick.utils import checksignallength, checkZ4S, earllatepicker, \
-    getSNR, fmpicker, checkPonsets, wadaticheck, get_pickparams, get_quality_class
+    getSNR, fmpicker, checkPonsets, wadaticheck, get_quality_class, PickingFailedException, MissingTraceException
-from pylot.core.util.utils import getPatternLine, gen_Pool,\
+from pylot.core.util.utils import getPatternLine, gen_Pool, \
-    get_Bool, identifyPhaseID, get_None, correct_iplot
+    get_bool, identifyPhaseID, get_none, correct_iplot
 from obspy.taup import TauPyModel
 from obspy import Trace
 def autopickevent(data, param, iplot=0, fig_dict=None, fig_dict_wadatijack=None, ncores=0, metadata=None, origin=None):
    """
@@ -232,20 +232,6 @@ class PickingContainer:
        self.Sflag = 0
 class MissingTraceException(ValueError):
    """
    Used to indicate missing traces in a obspy.core.stream.Stream object
    """
    pass
 class PickingFailedException(Exception):
    """
    Raised when picking fails due to missing values etc.
    """
    pass
 class AutopickStation(object):
    def __init__(self, wfstream, pickparam, verbose, iplot=0, fig_dict=None, metadata=None, origin=None):
@@ -272,7 +258,7 @@ class AutopickStation(object):
        self.pickparams = copy.deepcopy(pickparam)
        self.verbose = verbose
        self.iplot = correct_iplot(iplot)
-        self.fig_dict = get_None(fig_dict)
+        self.fig_dict = get_none(fig_dict)
        self.metadata = metadata
        self.origin = origin
@@ -337,7 +323,8 @@ class AutopickStation(object):
        for key in self.channelorder:
            waveform_data[key] = self.wfstream.select(component=key)  # try ZNE first
            if len(waveform_data[key]) == 0:
-                waveform_data[key] = self.wfstream.select(component=str(self.channelorder[key])) # use 123 as second option
+                waveform_data[key] = self.wfstream.select(
                    component=str(self.channelorder[key]))  # use 123 as second option
        return waveform_data['Z'], waveform_data['N'], waveform_data['E']
    def get_traces_from_streams(self):
@@ -428,7 +415,7 @@ class AutopickStation(object):
            if station_coords is None:
                exit_taupy()
                raise AttributeError('Warning: Could not find station in metadata')
-            # TODO raise when metadata.get_coordinates returns None
+            # TODO: raise when metadata.get_coordinates returns None
            source_origin = origin[0]
            model = TauPyModel(taup_model)
            taup_phases = self.pickparams['taup_phases']
@@ -470,11 +457,13 @@ class AutopickStation(object):
            """If taupy failed to calculate theoretical starttimes, picking continues.
            For this a clean exit is required, since the P starttime is no longer relative to the theoretic onset but
            to the vertical trace starttime, eg. it can't be < 0."""
            if self.pickparams["pstart"] < 0:
            # TODO here the pickparams is modified, instead of a copy
            if self.pickparams["pstart"] < 0:
                self.pickparams["pstart"] = 0
            if self.pickparams["sstart"] < 0:
                self.pickparams["sstart"] = 0
-        if self.pickparams["use_taup"] is False:
+        if get_bool(self.pickparams["use_taup"]) is False:
            # correct user mistake where a relative cuttime is selected (pstart < 0) but use of taupy is disabled/ has
            # not the required parameters
            exit_taupy()
@@ -498,6 +487,20 @@ class AutopickStation(object):
        self.pickparams["pstart"] = max(self.pickparams["pstart"], 0)
        self.pickparams["pstop"] = min(self.pickparams["pstop"], len(self.ztrace) * self.ztrace.stats.delta)
        if self.horizontal_traces_exist():
            # for the two horizontal components take earliest and latest time to make sure that the s onset is not clipped
            # if start and endtime of horizontal traces differ, the s windowsize will automatically increase
            trace_s_start = min([self.etrace.stats.starttime, self.ntrace.stats.starttime])
            # modifiy sstart and sstop relative to estimated first S arrival (relative to station time axis)
            self.pickparams["sstart"] += (self.origin[0].time + estFirstS) - trace_s_start
            self.pickparams["sstop"] += (self.origin[0].time + estFirstS) - trace_s_start
            print('autopick: CF calculation times respectively:'
                  ' sstart: {} s, sstop: {} s'.format(self.pickparams["sstart"], self.pickparams["sstop"]))
            # make sure pstart and pstop are inside the starttime/endtime of horizontal traces
            self.pickparams["sstart"] = max(self.pickparams["sstart"], 0)
            self.pickparams["sstop"] = min(self.pickparams["sstop"], len(self.ntrace) * self.ntrace.stats.delta,
                                           len(self.etrace) * self.etrace.stats.delta)
    def autopickstation(self):
        """
        Main function of autopickstation, which calculates P and S picks and returns them in a dictionary.
@@ -507,6 +510,17 @@ class AutopickStation(object):
        station's value is the station name on which the picks were calculated.
        :rtype: dict
        """
        if get_bool(self.pickparams['use_taup']) is True and self.origin is not None:
            try:
                # modify pstart, pstop, sstart, sstop to be around theoretical onset if taupy should be used,
                # else do nothing
                self.modify_starttimes_taupy()
            except AttributeError as ae:
                print(ae)
            except MissingTraceException as mte:
                print(mte)
        try:
            self.pick_p_phase()
        except MissingTraceException as mte:
@@ -514,7 +528,9 @@ class AutopickStation(object):
        except PickingFailedException as pfe:
            print(pfe)
-        if self.horizontal_traces_exist() and self.p_results.weight is not None and self.p_results.weight < 4:
+        if self.horizontal_traces_exist():
            if (self.p_results.weight is not None and self.p_results.weight < 4) or \
                    get_bool(self.pickparams.get('use_taup')):
                try:
                    self.pick_s_phase()
                except MissingTraceException as mte:
@@ -524,7 +540,7 @@ class AutopickStation(object):
        self.plot_pick_results()
        self.finish_picking()
-        return [{'P': self.p_results, 'S':self.s_results}, self.ztrace.stats.station]
+        return [{'P': self.p_results, 'S': self.s_results}, self.ztrace.stats.station]
    def finish_picking(self):
@@ -588,12 +604,14 @@ class AutopickStation(object):
                plt_flag = 0
            fig._tight = True
            ax1 = fig.add_subplot(311)
-            tdata = np.linspace(start=0, stop=self.ztrace.stats.endtime-self.ztrace.stats.starttime, num=self.ztrace.stats.npts)
+            tdata = np.linspace(start=0, stop=self.ztrace.stats.endtime - self.ztrace.stats.starttime,
                                num=self.ztrace.stats.npts)
            # plot tapered trace filtered with bpz2 filter settings
-            ax1.plot(tdata, self.tr_filt_z_bpz2.data/max(self.tr_filt_z_bpz2.data), color=linecolor, linewidth=0.7, label='Data')
+            ax1.plot(tdata, self.tr_filt_z_bpz2.data / max(self.tr_filt_z_bpz2.data), color=linecolor, linewidth=0.7,
                     label='Data')
            if self.p_results.weight < 4:
                # plot CF of initial onset (HOScf or ARZcf)
-                ax1.plot(self.cf1.getTimeArray(), self.cf1.getCF()/max(self.cf1.getCF()), 'b', label='CF1')
+                ax1.plot(self.cf1.getTimeArray(), self.cf1.getCF() / max(self.cf1.getCF()), 'b', label='CF1')
            if self.p_data.p_aic_plot_flag == 1:
                aicpick = self.p_data.aicpick
                refPpick = self.p_data.refPpick
@@ -628,38 +646,44 @@ class AutopickStation(object):
            ax1.set_ylim([-1.5, 1.5])
            ax1.set_ylabel('Normalized Counts')
-            if self.horizontal_traces_exist() and self.s_data.Sflag == 1:
+            if self.horizontal_traces_exist():# and self.s_data.Sflag == 1:
                # plot E trace
                ax2 = fig.add_subplot(3, 1, 2, sharex=ax1)
-                th1data = np.linspace(0, self.etrace.stats.endtime-self.etrace.stats.starttime, self.etrace.stats.npts)
+                th1data = np.linspace(0, self.etrace.stats.endtime - self.etrace.stats.starttime,
                                      self.etrace.stats.npts)
                # plot filtered and tapered waveform
-                ax2.plot(th1data, self.etrace.data / max(self.etrace.data), color=linecolor, linewidth=0.7, label='Data')
+                ax2.plot(th1data, self.etrace.data / max(self.etrace.data), color=linecolor, linewidth=0.7,
                         label='Data')
                if self.p_results.weight < 4:
                    # plot initial CF (ARHcf or AR3Ccf)
-                    ax2.plot(self.arhcf1.getTimeArray(), self.arhcf1.getCF() / max(self.arhcf1.getCF()), 'b', label='CF1')
+                    ax2.plot(self.arhcf1.getTimeArray(), self.arhcf1.getCF() / max(self.arhcf1.getCF()), 'b',
                             label='CF1')
                    if self.s_data.aicSflag == 1 and self.s_results.weight <= 4:
                        aicarhpick = self.aicarhpick
                        refSpick = self.refSpick
                        # plot second cf, used for determing precise onset (ARHcf or AR3Ccf)
-                        ax2.plot(self.arhcf2.getTimeArray(), self.arhcf2.getCF() / max(self.arhcf2.getCF()), 'm', label='CF2')
+                        ax2.plot(self.arhcf2.getTimeArray(), self.arhcf2.getCF() / max(self.arhcf2.getCF()), 'm',
                                 label='CF2')
                        # plot preliminary onset time, calculated from CF1
                        ax2.plot([aicarhpick.getpick(), aicarhpick.getpick()], [-1, 1], 'g', label='Initial S Onset')
                        ax2.plot([aicarhpick.getpick() - 0.5, aicarhpick.getpick() + 0.5], [1, 1], 'g')
                        ax2.plot([aicarhpick.getpick() - 0.5, aicarhpick.getpick() + 0.5], [-1, -1], 'g')
                        # plot precise onset time, calculated from CF2
-                        ax2.plot([refSpick.getpick(), refSpick.getpick()], [-1.3, 1.3], 'g', linewidth=2, label='Final S Pick')
+                        ax2.plot([refSpick.getpick(), refSpick.getpick()], [-1.3, 1.3], 'g', linewidth=2,
                                 label='Final S Pick')
                        ax2.plot([refSpick.getpick() - 0.5, refSpick.getpick() + 0.5], [1.3, 1.3], 'g', linewidth=2)
                        ax2.plot([refSpick.getpick() - 0.5, refSpick.getpick() + 0.5], [-1.3, -1.3], 'g', linewidth=2)
                        ax2.plot([self.s_results.lpp, self.s_results.lpp], [-1.1, 1.1], 'g--', label='lpp')
                        ax2.plot([self.s_results.epp, self.s_results.epp], [-1.1, 1.1], 'g--', label='epp')
                        title = '{channel}, S weight={sweight}, SNR={snr:7.2}, SNR[dB]={snrdb:7.2}'
-                        ax2.set_title(title.format(channel=self.etrace.stats.channel,
+                        ax2.set_title(title.format(channel=str(self.etrace.stats.channel),
-                                                   sweight=self.s_results.weight,
+                                                   sweight=str(self.s_results.weight),
-                                                   snr=self.s_results.snr,
+                                                   snr=str(self.s_results.snr),
-                                                   snrdb=self.s_results.snrdb))
+                                                   snrdb=str(self.s_results.snrdb)))
                    else:
                        title = '{channel}, S weight={sweight}, SNR=None, SNR[dB]=None'
-                        ax2.set_title(title.format(channel=self.etrace.stats.channel, sweight=self.s_results.weight))
+                        ax2.set_title(title.format(channel=str(self.etrace.stats.channel),
                                                   sweight=str(self.s_results.weight)))
                ax2.legend(loc=1)
                ax2.set_yticks([])
                ax2.set_ylim([-1.5, 1.5])
@@ -667,15 +691,19 @@ class AutopickStation(object):
                # plot N trace
                ax3 = fig.add_subplot(3, 1, 3, sharex=ax1)
-                th2data= np.linspace(0, self.ntrace.stats.endtime-self.ntrace.stats.starttime, self.ntrace.stats.npts)
+                th2data = np.linspace(0, self.ntrace.stats.endtime - self.ntrace.stats.starttime,
                                      self.ntrace.stats.npts)
                # plot trace
-                ax3.plot(th2data, self.ntrace.data / max(self.ntrace.data), color=linecolor, linewidth=0.7, label='Data')
+                ax3.plot(th2data, self.ntrace.data / max(self.ntrace.data), color=linecolor, linewidth=0.7,
                         label='Data')
                if self.p_results.weight < 4:
-                    p22, = ax3.plot(self.arhcf1.getTimeArray(), self.arhcf1.getCF() / max(self.arhcf1.getCF()), 'b', label='CF1')
+                    p22, = ax3.plot(self.arhcf1.getTimeArray(), self.arhcf1.getCF() / max(self.arhcf1.getCF()), 'b',
                                    label='CF1')
                    if self.s_data.aicSflag == 1:
                        aicarhpick = self.aicarhpick
                        refSpick = self.refSpick
-                        ax3.plot(self.arhcf2.getTimeArray(), self.arhcf2.getCF() / max(self.arhcf2.getCF()), 'm', label='CF2')
+                        ax3.plot(self.arhcf2.getTimeArray(), self.arhcf2.getCF() / max(self.arhcf2.getCF()), 'm',
                                 label='CF2')
                        ax3.plot([aicarhpick.getpick(), aicarhpick.getpick()], [-1, 1], 'g', label='Initial S Onset')
                        ax3.plot([aicarhpick.getpick() - 0.5, aicarhpick.getpick() + 0.5], [1, 1], 'g')
                        ax3.plot([aicarhpick.getpick() - 0.5, aicarhpick.getpick() + 0.5], [-1, -1], 'g')
@@ -716,7 +744,8 @@ class AutopickStation(object):
        if aicpick.getpick() is None:
            msg = "Bad initial (AIC) P-pick, skipping this onset!\nAIC-SNR={0}, AIC-Slope={1}counts/s\n " \
                  "(min. AIC-SNR={2}, min. AIC-Slope={3}counts/s)"
-            msg = msg.format(aicpick.getSNR(), aicpick.getSlope(), self.pickparams["minAICPSNR"], self.pickparams["minAICPslope"])
+            msg = msg.format(aicpick.getSNR(), aicpick.getSlope(), self.pickparams["minAICPSNR"],
                             self.pickparams["minAICPslope"])
            self.vprint(msg)
            return 0
        # Quality check initial pick with minimum signal length
@@ -726,14 +755,16 @@ class AutopickStation(object):
        if len(self.nstream) == 0 or len(self.estream) == 0:
            msg = 'One or more horizontal component(s) missing!\n' \
                  'Signal length only checked on vertical component!\n' \
-                  'Decreasing minsiglengh from {0} to {1}'\
+                  'Decreasing minsiglengh from {0} to {1}' \
                .format(minsiglength, minsiglength / 2)
            self.vprint(msg)
            minsiglength = minsiglength / 2
        else:
            # filter, taper other traces as well since signal length is compared on all traces
-            trH1_filt, _ = self.prepare_wfstream(self.estream, freqmin=self.pickparams["bph1"][0], freqmax=self.pickparams["bph1"][1])
+            trH1_filt, _ = self.prepare_wfstream(self.estream, freqmin=self.pickparams["bph1"][0],
-            trH2_filt, _ = self.prepare_wfstream(self.nstream, freqmin=self.pickparams["bph1"][0], freqmax=self.pickparams["bph1"][1])
+                                                 freqmax=self.pickparams["bph1"][1])
            trH2_filt, _ = self.prepare_wfstream(self.nstream, freqmin=self.pickparams["bph1"][0],
                                                 freqmax=self.pickparams["bph1"][1])
            zne += trH1_filt
            zne += trH2_filt
            minsiglength = minsiglength
@@ -780,15 +811,6 @@ class AutopickStation(object):
        # save filtered trace in instance for later plotting
        self.tr_filt_z_bpz2 = tr_filt
        if get_Bool(self.pickparams['use_taup']) is True and self.origin is not None:
            try:
                # modify pstart, pstop to be around theoretical onset if taupy should be used, else does nothing
                self.modify_starttimes_taupy()
            except AttributeError as ae:
                print(ae)
            except MissingTraceException as mte:
                print(mte)
        Lc = self.pickparams['pstop'] - self.pickparams['pstart']
        Lwf = self.ztrace.stats.endtime - self.ztrace.stats.starttime
@@ -819,15 +841,18 @@ class AutopickStation(object):
        # get preliminary onset time from AIC-CF
        self.set_current_figure('aicFig')
        aicpick = AICPicker(aiccf, self.pickparams["tsnrz"], self.pickparams["pickwinP"], self.iplot,
-                            Tsmooth=self.pickparams["aictsmooth"], fig=self.current_figure, linecolor=self.current_linecolor)
+                            Tsmooth=self.pickparams["aictsmooth"], fig=self.current_figure,
                            linecolor=self.current_linecolor)
        # save aicpick for plotting later
        self.p_data.aicpick = aicpick
        # add pstart and pstop to aic plot
        if self.current_figure:
            # TODO remove plotting from picking, make own plot function
            for ax in self.current_figure.axes:
-                ax.vlines(self.pickparams["pstart"], ax.get_ylim()[0], ax.get_ylim()[1], color='c', linestyles='dashed', label='P start')
+                ax.vlines(self.pickparams["pstart"], ax.get_ylim()[0], ax.get_ylim()[1], color='c', linestyles='dashed',
-                ax.vlines(self.pickparams["pstop"], ax.get_ylim()[0], ax.get_ylim()[1], color='c', linestyles='dashed', label='P stop')
+                          label='P start')
                ax.vlines(self.pickparams["pstop"], ax.get_ylim()[0], ax.get_ylim()[1], color='c', linestyles='dashed',
                          label='P stop')
                ax.legend(loc=1)
        Pflag = self._pick_p_quality_control(aicpick, z_copy, tr_filt)
@@ -841,7 +866,8 @@ class AutopickStation(object):
            error_msg = 'AIC P onset slope to small: got {}, min {}'.format(slope, self.pickparams["minAICPslope"])
            raise PickingFailedException(error_msg)
        if aicpick.getSNR() < self.pickparams["minAICPSNR"]:
-            error_msg = 'AIC P onset SNR to small: got {}, min {}'.format(aicpick.getSNR(), self.pickparams["minAICPSNR"])
+            error_msg = 'AIC P onset SNR to small: got {}, min {}'.format(aicpick.getSNR(),
                                                                          self.pickparams["minAICPSNR"])
            raise PickingFailedException(error_msg)
        self.p_data.p_aic_plot_flag = 1
@@ -849,7 +875,8 @@ class AutopickStation(object):
              'autopickstation: re-filtering vertical trace...'.format(aicpick.getSlope(), aicpick.getSNR())
        self.vprint(msg)
        # refilter waveform with larger bandpass
-        tr_filt, z_copy = self.prepare_wfstream(self.zstream, freqmin=self.pickparams["bpz2"][0], freqmax=self.pickparams["bpz2"][1])
+        tr_filt, z_copy = self.prepare_wfstream(self.zstream, freqmin=self.pickparams["bpz2"][0],
                                                freqmax=self.pickparams["bpz2"][1])
        # save filtered trace in instance for later plotting
        self.tr_filt_z_bpz2 = tr_filt
        # determine new times around initial onset
@@ -864,22 +891,26 @@ class AutopickStation(object):
                                                             'corrupted'.format(self.pickparams["algoP"])
        self.set_current_figure('refPpick')
        # get refined onset time from CF2
-        refPpick = PragPicker(self.cf2, self.pickparams["tsnrz"], self.pickparams["pickwinP"], self.iplot, self.pickparams["ausP"],
+        refPpick = PragPicker(self.cf2, self.pickparams["tsnrz"], self.pickparams["pickwinP"], self.iplot,
-                              self.pickparams["tsmoothP"], aicpick.getpick(), self.current_figure, self.current_linecolor)
+                              self.pickparams["ausP"],
                              self.pickparams["tsmoothP"], aicpick.getpick(), self.current_figure,
                              self.current_linecolor)
        # save PragPicker result for plotting
        self.p_data.refPpick = refPpick
        self.p_results.mpp = refPpick.getpick()
        if self.p_results.mpp is None:
            msg = 'Bad initial (AIC) P-pick, skipping this onset!\n AIC-SNR={}, AIC-Slope={}counts/s\n' \
                  '(min. AIC-SNR={}, min. AIC-Slope={}counts/s)'
-            msg.format(aicpick.getSNR(), aicpick.getSlope(), self.pickparams["minAICPSNR"], self.pickparams["minAICPslope"])
+            msg.format(aicpick.getSNR(), aicpick.getSlope(), self.pickparams["minAICPSNR"],
                       self.pickparams["minAICPslope"])
            self.vprint(msg)
            self.s_data.Sflag = 0
            raise PickingFailedException(msg)
        # quality assessment, get earliest/latest pick and symmetrized uncertainty
-        #todo quality assessment in own function
+        # todo quality assessment in own function
        self.set_current_figure('el_Ppick')
-        elpicker_results = earllatepicker(z_copy, self.pickparams["nfacP"], self.pickparams["tsnrz"], self.p_results.mpp,
+        elpicker_results = earllatepicker(z_copy, self.pickparams["nfacP"], self.pickparams["tsnrz"],
                                          self.p_results.mpp,
                                          self.iplot, fig=self.current_figure, linecolor=self.current_linecolor)
        self.p_results.epp, self.p_results.lpp, self.p_results.spe = elpicker_results
        snr_results = getSNR(z_copy, self.pickparams["tsnrz"], self.p_results.mpp)
@@ -887,10 +918,11 @@ class AutopickStation(object):
        # weight P-onset using symmetric error
        self.p_results.weight = get_quality_class(self.p_results.spe, self.pickparams["timeerrorsP"])
-        if self.p_results.weight <= self.pickparams["minfmweight"] and self.p_results.snr >= self.pickparams["minFMSNR"]:
+        if self.p_results.weight <= self.pickparams["minfmweight"] and self.p_results.snr >= self.pickparams[
            "minFMSNR"]:
            # if SNR is high enough, try to determine first motion of onset
            self.set_current_figure('fm_picker')
-            self.p_results.fm = fmpicker(self.zstream, z_copy, self.pickparams["fmpickwin"], self.p_results.mpp,
+            self.p_results.fm = fmpicker(self.zstream.copy(), z_copy, self.pickparams["fmpickwin"], self.p_results.mpp,
                                         self.iplot, self.current_figure, self.current_linecolor)
        msg = "autopickstation: P-weight: {}, SNR: {}, SNR[dB]: {}, Polarity: {}"
        msg = msg.format(self.p_results.weight, self.p_results.snr, self.p_results.snrdb, self.p_results.fm)
@@ -960,7 +992,7 @@ class AutopickStation(object):
            trH1_filt, _ = self.prepare_wfstream(self.zstream, filter_freq_min, filter_freq_max)
            trH2_filt, _ = self.prepare_wfstream(self.estream, filter_freq_min, filter_freq_max)
            trH3_filt, _ = self.prepare_wfstream(self.nstream, filter_freq_min, filter_freq_max)
-            h_copy =self. hdat.copy()
+            h_copy = self.hdat.copy()
            h_copy[0].data = trH1_filt.data
            h_copy[1].data = trH2_filt.data
            h_copy[2].data = trH3_filt.data
@@ -1102,7 +1134,9 @@ class AutopickStation(object):
                  ''.format(self.s_results.weight, self.s_results.snr, self.s_results.snrdb))
    def pick_s_phase(self):
-
+        if get_bool(self.pickparams.get('use_taup')) is True:
            cuttimesh = (self.pickparams.get('sstart'), self.pickparams.get('sstop'))
        else:
            # determine time window for calculating CF after P onset
            cuttimesh = self._calculate_cuttimes(type='S', iteration=1)
@@ -1115,7 +1149,8 @@ class AutopickStation(object):
        # get preliminary onset time from AIC cf
        self.set_current_figure('aicARHfig')
        aicarhpick = AICPicker(haiccf, self.pickparams["tsnrh"], self.pickparams["pickwinS"], self.iplot,
-                               Tsmooth=self.pickparams["aictsmoothS"], fig=self.current_figure, linecolor=self.current_linecolor)
+                               Tsmooth=self.pickparams["aictsmoothS"], fig=self.current_figure,
                               linecolor=self.current_linecolor)
        # save pick for later plotting
        self.aicarhpick = aicarhpick
@@ -1126,8 +1161,10 @@ class AutopickStation(object):
        # get refined onset time from CF2
        self.set_current_figure('refSpick')
-        refSpick = PragPicker(arhcf2, self.pickparams["tsnrh"], self.pickparams["pickwinS"], self.iplot, self.pickparams["ausS"],
+        refSpick = PragPicker(arhcf2, self.pickparams["tsnrh"], self.pickparams["pickwinS"], self.iplot,
-                              self.pickparams["tsmoothS"], aicarhpick.getpick(), self.current_figure, self.current_linecolor)
+                              self.pickparams["ausS"],
                              self.pickparams["tsmoothS"], aicarhpick.getpick(), self.current_figure,
                              self.current_linecolor)
        # save refSpick for later plotitng
        self.refSpick = refSpick
        self.s_results.mpp = refSpick.getpick()
@@ -1151,7 +1188,6 @@ class AutopickStation(object):
        self.current_linecolor = plot_style['linecolor']['rgba_mpl']
 def autopickstation(wfstream, pickparam, verbose=False, iplot=0, fig_dict=None, metadata=None, origin=None):
    """
    Main function to calculate picks for the station.
@@ -16,11 +16,12 @@ autoregressive prediction: application ot local and regional distances, Geophys.
 :author: MAGS2 EP3 working group
 """
 import numpy as np
 from scipy import signal
 from obspy.core import Stream
 from pylot.core.pick.utils import PickingFailedException
 class CharacteristicFunction(object):
    """
@@ -259,7 +260,7 @@ class HOScf(CharacteristicFunction):
        """
        Function to calculate skewness (statistics of order 3) or kurtosis
        (statistics of order 4), using one long moving window, as published
-        in Kueperkoch et al. (2010).
+        in Kueperkoch et al. (2010), or order 2, i.e. STA/LTA.
        :param data: data, time series (whether seismogram or CF)
        :type data: tuple
        :return: HOS cf
@@ -276,28 +277,47 @@ class HOScf(CharacteristicFunction):
        elif self.getOrder() == 4:  # this is kurtosis
            y = np.power(xnp, 4)
            y1 = np.power(xnp, 2)
        elif self.getOrder() == 2:  # this is variance, used for STA/LTA processing
            y = np.power(xnp, 2)
            y1 = np.power(xnp, 2)
        # Initialisation
        # t2: long term moving window
        ilta = int(round(self.getTime2() / self.getIncrement()))
        ista = int(round((self.getTime2() / 10) / self.getIncrement()))  # TODO: still hard coded!!
        lta = y[0]
        lta1 = y1[0]
        sta = y[0]
        # moving windows
        LTA = np.zeros(len(xnp))
        STA = np.zeros(len(xnp))
        for j in range(0, len(xnp)):
            if j < 4:
                LTA[j] = 0
                STA[j] = 0
            elif j <= ista and self.getOrder() == 2:
                lta = (y[j] + lta * (j - 1)) / j
                if self.getOrder() == 2:
                    sta = (y[j] + sta * (j - 1)) / j
            # elif j < 4:
            elif j <= ilta:
                lta = (y[j] + lta * (j - 1)) / j
                lta1 = (y1[j] + lta1 * (j - 1)) / j
                if self.getOrder() == 2:
                    sta = (y[j] - y[j - ista]) / ista + sta
            else:
                lta = (y[j] - y[j - ilta]) / ilta + lta
                lta1 = (y1[j] - y1[j - ilta]) / ilta + lta1
                if self.getOrder() == 2:
                    sta = (y[j] - y[j - ista]) / ista + sta
            # define LTA
            if self.getOrder() == 3:
                LTA[j] = lta / np.power(lta1, 1.5)
            elif self.getOrder() == 4:
                LTA[j] = lta / np.power(lta1, 2)
            else:
                LTA[j] = lta
                STA[j] = sta
        # remove NaN's with first not-NaN-value,
        # so autopicker doesnt pick discontinuity at start of the trace
@@ -306,14 +326,18 @@ class HOScf(CharacteristicFunction):
            first = ind[0]
            LTA[:first] = LTA[first]
        if self.getOrder() > 2:
            self.cf = LTA
        else:  # order 2 means STA/LTA!
            self.cf = STA / LTA
        self.xcf = x
 class ARZcf(CharacteristicFunction):
    def __init__(self, data, cut, t1, t2, pickparams):
-        super(ARZcf, self).__init__(data, cut, t1=t1, t2=t2, order=pickparams["Parorder"], fnoise=pickparams["addnoise"])
+        super(ARZcf, self).__init__(data, cut, t1=t1, t2=t2, order=pickparams["Parorder"],
                                    fnoise=pickparams["addnoise"])
    def calcCF(self, data):
        """
@@ -448,7 +472,8 @@ class ARZcf(CharacteristicFunction):
 class ARHcf(CharacteristicFunction):
    def __init__(self, data, cut, t1, t2, pickparams):
-        super(ARHcf, self).__init__(data, cut, t1=t1, t2=t2, order=pickparams["Sarorder"], fnoise=pickparams["addnoise"])
+        super(ARHcf, self).__init__(data, cut, t1=t1, t2=t2, order=pickparams["Sarorder"],
                                    fnoise=pickparams["addnoise"])
    def calcCF(self, data):
        """
@@ -465,6 +490,9 @@ class ARHcf(CharacteristicFunction):
        print('Calculating AR-prediction error from both horizontal traces ...')
        xnp = self.getDataArray(self.getCut())
        if len(xnp[0]) == 0:
            raise PickingFailedException('calcCF: Found empty data trace for cut times. Return')
        n0 = np.isnan(xnp[0].data)
        if len(n0) > 1:
            xnp[0].data[n0] = 0
@@ -600,7 +628,8 @@ class ARHcf(CharacteristicFunction):
 class AR3Ccf(CharacteristicFunction):
    def __init__(self, data, cut, t1, t2, pickparams):
-        super(AR3Ccf, self).__init__(data, cut, t1=t1, t2=t2, order=pickparams["Sarorder"], fnoise=pickparams["addnoise"])
+        super(AR3Ccf, self).__init__(data, cut, t1=t1, t2=t2, order=pickparams["Sarorder"],
                                     fnoise=pickparams["addnoise"])
    def calcCF(self, data):
        """
@@ -2,10 +2,11 @@
 # -*- coding: utf-8 -*-
 import copy
 import matplotlib.pyplot as plt
 import numpy as np
 import operator
 import os
 import matplotlib.pyplot as plt
 import numpy as np
 from obspy.core import AttribDict
 from pylot.core.util.pdf import ProbabilityDensityFunction
@@ -400,6 +401,7 @@ class PDFstatistics(object):
    This object can be used to get various statistic values from probability density functions.
    Takes a path as argument.
    """
    # TODO: change root to datapath
    def __init__(self, directory):
@@ -19,9 +19,10 @@ calculated after Diehl & Kissling (2009).
 :author: MAGS2 EP3 working group / Ludger Kueperkoch
 """
 import warnings
 import matplotlib.pyplot as plt
 import numpy as np
 import warnings
 from scipy.signal import argrelmax, argrelmin
 from pylot.core.pick.charfuns import CharacteristicFunction
@@ -177,7 +178,9 @@ class AICPicker(AutoPicker):
        aic = tap * self.cf + max(abs(self.cf))
        # smooth AIC-CF
        ismooth = int(round(self.Tsmooth / self.dt))
-        aicsmooth = np.zeros(len(aic))
+        # MP MP better start with original data than zeros if array shall be smoothed, created artificial value before
        # when starting with i in range(1...) loop below and subtracting offset afterwards
        aicsmooth = np.copy(aic)
        if len(aic) < ismooth:
            print('AICPicker: Tsmooth larger than CF!')
            return
@@ -187,7 +190,7 @@ class AICPicker(AutoPicker):
                    ii1 = i - ismooth
                    aicsmooth[i] = aicsmooth[i - 1] + (aic[i] - aic[ii1]) / ismooth
                else:
-                    aicsmooth[i] = np.mean(aic[1: i])
+                    aicsmooth[i] = np.mean(aic[0: i]) # MP MP created np.nan for i=1
        # remove offset in AIC function
        offset = abs(min(aic) - min(aicsmooth))
        aicsmooth = aicsmooth - offset
@@ -196,7 +199,7 @@ class AICPicker(AutoPicker):
        # minimum in AIC function 
        icfmax = np.argmax(cf)
-        # MP MP testing threshold
+        # TODO: If this shall be kept, maybe add thresh_factor to pylot parameters
        thresh_hit = False
        thresh_factor = 0.7
        thresh = thresh_factor * cf[icfmax]
@@ -208,7 +211,6 @@ class AICPicker(AutoPicker):
                if sample <= cf[index - 1]:
                    icfmax = index - 1
                    break
        # MP MP ---
        # find minimum in AIC-CF front of maximum of HOS/AR-CF
        lpickwindow = int(round(self.PickWindow / self.dt))
@@ -335,7 +337,7 @@ class AICPicker(AutoPicker):
                    self.slope = 1 / (len(dataslope) * self.Data[0].stats.delta) * (datafit[-1] - datafit[0])
                    # normalize slope to maximum of cf to make it unit independent
                    self.slope /= aicsmooth[iaicmax]
-            except ValueError as e:
+            except Exception as e:
                print("AICPicker: Problems with data fitting! {}".format(e))
        else:
@@ -476,7 +478,7 @@ class PragPicker(AutoPicker):
            cfpick_r = 0
            cfpick_l = 0
            lpickwindow = int(round(self.PickWindow / self.dt))
-            #for i in range(max(np.insert(ipick, 0, 2)), min([ipick1 + lpickwindow + 1, len(self.cf) - 1])):
+            # for i in range(max(np.insert(ipick, 0, 2)), min([ipick1 + lpickwindow + 1, len(self.cf) - 1])):
            #    # local minimum
            #    if self.cf[i + 1] > self.cf[i] <= self.cf[i - 1]:
            #        if cfsmooth[i - 1] * (1 + aus1) >= cfsmooth[i]:
@@ -508,9 +510,9 @@ class PragPicker(AutoPicker):
            if flagpick_l > 0 and flagpick_r > 0 and cfpick_l <= 3 * cfpick_r:
                self.Pick = pick_l
                pickflag = 1
-            elif flagpick_l > 0 and flagpick_r > 0 and cfpick_l >= cfpick_r:
+            # elif flagpick_l > 0 and flagpick_r > 0 and cfpick_l >= cfpick_r:
-                self.Pick = pick_r # MP MP there is no pick_r defined, commented out after commit of LK on 29.07.2020 (see above)
+            #     self.Pick = pick_r
-                pickflag = 1
+            #     pickflag = 1
            elif flagpick_l == 0 and flagpick_r > 0 and cfpick_l >= cfpick_r:
                self.Pick = pick_l
                pickflag = 1
@@ -9,12 +9,13 @@
 """
 import warnings
 import matplotlib.pyplot as plt
 import numpy as np
 from scipy.signal import argrelmax
 from obspy.core import Stream, UTCDateTime
 from scipy.signal import argrelmax
-from pylot.core.util.utils import get_Bool, get_None, SetChannelComponents
+from pylot.core.util.utils import get_bool, get_none, SetChannelComponents
 def earllatepicker(X, nfac, TSNR, Pick1, iplot=0, verbosity=1, fig=None, linecolor='k'):
@@ -61,8 +62,8 @@ def earllatepicker(X, nfac, TSNR, Pick1, iplot=0, verbosity=1, fig=None, linecol
    plt_flag = 0
    try:
        iplot = int(iplot)
-    except:
+    except ValueError:
-        if get_Bool(iplot):
+        if get_bool(iplot):
            iplot = 2
        else:
            iplot = 0
@@ -135,7 +136,7 @@ def earllatepicker(X, nfac, TSNR, Pick1, iplot=0, verbosity=1, fig=None, linecol
    PickError = symmetrize_error(diffti_te, diffti_tl)
    if iplot > 1:
-        if get_None(fig) is None:
+        if get_none(fig) is None:
            fig = plt.figure()  # iplot)
            plt_flag = 1
        fig._tight = True
@@ -343,7 +344,7 @@ def fmpicker(Xraw, Xfilt, pickwin, Pick, iplot=0, fig=None, linecolor='k'):
        print("fmpicker: Found polarity %s" % FM)
    if iplot > 1:
-        if get_None(fig) is None:
+        if get_none(fig) is None:
            fig = plt.figure()  # iplot)
            plt_flag = 1
        fig._tight = True
@@ -536,9 +537,10 @@ def getslopewin(Tcf, Pick, tslope):
    :rtype: `numpy.ndarray`
    """
    # TODO: fill out docstring
-    slope = np.where( (Tcf <= min(Pick + tslope, Tcf[-1])) & (Tcf >= Pick) )
+    slope = np.where((Tcf <= min(Pick + tslope, Tcf[-1])) & (Tcf >= Pick))
    return slope[0]
 def getResolutionWindow(snr, extent):
    """
    Produce the half of the time resolution window width from given SNR value
@@ -814,7 +816,7 @@ def checksignallength(X, pick, minsiglength, pickparams, iplot=0, fig=None, line
    try:
        iplot = int(iplot)
    except:
-        if get_Bool(iplot):
+        if get_bool(iplot):
            iplot = 2
        else:
            iplot = 0
@@ -866,7 +868,7 @@ def checksignallength(X, pick, minsiglength, pickparams, iplot=0, fig=None, line
            returnflag = 0
    if iplot > 1:
-        if get_None(fig) is None:
+        if get_none(fig) is None:
            fig = plt.figure()  # iplot)
            plt_flag = 1
        fig._tight = True
@@ -888,6 +890,8 @@ def checksignallength(X, pick, minsiglength, pickparams, iplot=0, fig=None, line
                input()
            except SyntaxError:
                pass
            except EOFError:
                pass
            plt.close(fig)
    return returnflag
@@ -1128,7 +1132,7 @@ def checkZ4S(X, pick, pickparams, iplot, fig=None, linecolor='k'):
    try:
        iplot = int(iplot)
    except:
-        if get_Bool(iplot):
+        if get_bool(iplot):
            iplot = 2
        else:
            iplot = 0
@@ -1209,14 +1213,14 @@ def checkZ4S(X, pick, pickparams, iplot, fig=None, linecolor='k'):
            t = np.linspace(diff_dict[key], trace.stats.endtime - trace.stats.starttime + diff_dict[key],
                            trace.stats.npts)
            if i == 0:
-                if get_None(fig) is None:
+                if get_none(fig) is None:
                    fig = plt.figure()  # self.iplot) ### WHY? MP MP
                    plt_flag = 1
                ax1 = fig.add_subplot(3, 1, i + 1)
                ax = ax1
                ax.set_title('CheckZ4S, Station %s' % zdat[0].stats.station)
            else:
-                if get_None(fig) is None:
+                if get_none(fig) is None:
                    fig = plt.figure()  # self.iplot) ### WHY? MP MP
                    plt_flag = 1
                ax = fig.add_subplot(3, 1, i + 1, sharex=ax1)
@@ -1318,7 +1322,7 @@ def get_quality_class(uncertainty, weight_classes):
    :return: quality of pick (0-4)
    :rtype: int
    """
-    if not uncertainty: return max(weight_classes)
+    if not uncertainty: return len(weight_classes)
    try:
        # create generator expression containing all indices of values in weight classes that are >= than uncertainty.
        # call next on it once to receive first value
@@ -1329,20 +1333,6 @@ def get_quality_class(uncertainty, weight_classes):
        quality = len(weight_classes)
    return quality
 def set_NaNs_to(data, nan_value):
    """
    Replace all NaNs in data with nan_value
    :param data: array holding data
    :type data: `~numpy.ndarray`
    :param nan_value: value which all NaNs are set to
    :type nan_value: float, int
    :return: data array with all NaNs replaced with nan_value
    :rtype: `~numpy.ndarray`
    """
    nn = np.isnan(data)
    if np.any(nn):
        data[nn] = nan_value
    return data
 def taper_cf(cf):
    """
@@ -1355,6 +1345,7 @@ def taper_cf(cf):
    tap = np.hanning(len(cf))
    return tap * cf
 def cf_positive(cf):
    """
    Shifts cf so that all values are positive
@@ -1365,6 +1356,7 @@ def cf_positive(cf):
    """
    return cf + max(abs(cf))
 def smooth_cf(cf, t_smooth, delta):
    """
    Smooth cf by taking samples over t_smooth length
@@ -1393,6 +1385,7 @@ def smooth_cf(cf, t_smooth, delta):
    cf_smooth -= offset  # remove offset from smoothed function
    return cf_smooth
 def check_counts_ms(data):
    """
    check if data is in counts or m/s
@@ -1475,8 +1468,10 @@ def get_pickparams(pickparam):
    :rtype: (dict, dict, dict, dict)
    """
    # Define names of all parameters in different groups
-    p_parameter_names = 'algoP pstart pstop use_taup taup_model tlta tsnrz hosorder bpz1 bpz2 pickwinP aictsmooth tsmoothP ausP nfacP tpred1z tdet1z Parorder addnoise Precalcwin minAICPslope minAICPSNR timeerrorsP checkwindowP minfactorP'.split(' ')
+    p_parameter_names = 'algoP pstart pstop use_taup taup_model tlta tsnrz hosorder bpz1 bpz2 pickwinP aictsmooth tsmoothP ausP nfacP tpred1z tdet1z Parorder addnoise Precalcwin minAICPslope minAICPSNR timeerrorsP checkwindowP minfactorP'.split(
-    s_parameter_names = 'algoS sstart sstop bph1 bph2 tsnrh pickwinS tpred1h tdet1h tpred2h tdet2h Sarorder aictsmoothS tsmoothS ausS minAICSslope minAICSSNR Srecalcwin nfacS timeerrorsS zfac checkwindowS minfactorS'.split(' ')
+        ' ')
    s_parameter_names = 'algoS sstart sstop bph1 bph2 tsnrh pickwinS tpred1h tdet1h tpred2h tdet2h Sarorder aictsmoothS tsmoothS ausS minAICSslope minAICSSNR Srecalcwin nfacS timeerrorsS zfac checkwindowS minfactorS'.split(
        ' ')
    first_motion_names = 'minFMSNR fmpickwin minfmweight'.split(' ')
    signal_length_names = 'minsiglength minpercent noisefactor'.split(' ')
    # Get list of values from pickparam by name
@@ -1490,15 +1485,16 @@ def get_pickparams(pickparam):
    first_motion_params = dict(zip(first_motion_names, fm_parameter_values))
    signal_length_params = dict(zip(signal_length_names, sl_parameter_values))
-    p_params['use_taup'] = get_Bool(p_params['use_taup'])
+    p_params['use_taup'] = get_bool(p_params['use_taup'])
    return p_params, s_params, first_motion_params, signal_length_params
 def getQualityFromUncertainty(uncertainty, Errors):
    # set initial quality to 4 (worst) and change only if one condition is hit
    quality = 4
-    if get_None(uncertainty) is None:
+    if get_none(uncertainty) is None:
        return quality
    if uncertainty <= Errors[0]:
@@ -1517,7 +1513,22 @@ def getQualityFromUncertainty(uncertainty, Errors):
    return quality
 if __name__ == '__main__':
    import doctest
    doctest.testmod()
 class PickingFailedException(Exception):
    """
    Raised when picking fails due to missing values etc.
    """
    pass
 class MissingTraceException(ValueError):
    """
    Used to indicate missing traces in a obspy.core.stream.Stream object
    """
    pass
@@ -1,27 +1,23 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-import sys
+import traceback
 import os
 import matplotlib
 from PySide2 import QtCore, QtGui, QtWidgets
 from PySide2.QtCore import Qt
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 import matplotlib.patheffects as PathEffects
 import cartopy.crs as ccrs
 import matplotlib.pyplot as plt
 import cartopy.feature as cf
-from cartopy.mpl.gridliner import LongitudeFormatter, LatitudeFormatter
+import matplotlib
-
+import matplotlib.patheffects as PathEffects
-import traceback
+import matplotlib.pyplot as plt
 import obspy
 import numpy as np
 import obspy
 from PySide2 import QtWidgets
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 from mpl_toolkits.axes_grid1.inset_locator import inset_axes
 from pylot.core.util.utils import identifyPhaseID
 from scipy.interpolate import griddata
-from pylot.core.util.widgets import PickDlg
+
 from pylot.core.pick.utils import get_quality_class
 from pylot.core.util.widgets import PickDlg
 matplotlib.use('Qt5Agg')
@@ -42,7 +38,7 @@ class MplCanvas(FigureCanvas):
 class Array_map(QtWidgets.QWidget):
    def __init__(self, parent, metadata, parameter=None, axes=None, annotate=True, pointsize=25.,
                 linewidth=1.5, width=5e6, height=2e6):
-        QtWidgets.QWidget.__init__(self)
+        QtWidgets.QWidget.__init__(self, parent=parent)
        assert (parameter is not None or parent is not None), 'either parent or parameter has to be set'
        # set properties
@@ -80,7 +76,6 @@ class Array_map(QtWidgets.QWidget):
        self._style = None if not hasattr(parent, '_style') else parent._style
        self.show()
    def init_map(self):
        self.init_colormap()
@@ -129,8 +124,8 @@ class Array_map(QtWidgets.QWidget):
        self.cmaps_box = QtWidgets.QComboBox()
        self.cmaps_box.setMaxVisibleItems(20)
        [self.cmaps_box.addItem(map_name) for map_name in sorted(plt.colormaps())]
-        # try to set to hsv as default
+        # try to set to viridis as default
-        self.cmaps_box.setCurrentIndex(self.cmaps_box.findText('hsv'))
+        self.cmaps_box.setCurrentIndex(self.cmaps_box.findText('viridis'))
        self.top_row.addWidget(QtWidgets.QLabel('Select a phase: '))
        self.top_row.addWidget(self.comboBox_phase)
@@ -173,7 +168,8 @@ class Array_map(QtWidgets.QWidget):
        self.canvas.fig.tight_layout()
    def add_merid_paral(self):
-        self.gridlines = self.canvas.axes.gridlines(draw_labels=False, alpha=0.6, color='gray', linewidth=self.linewidth/2, zorder=7)
+        self.gridlines = self.canvas.axes.gridlines(draw_labels=False, alpha=0.6, color='gray',
                                                    linewidth=self.linewidth / 2, zorder=7)
        # TODO: current cartopy version does not support label removal. Devs are working on it.
        #  Should be fixed in coming cartopy versions
        # self.gridlines.xformatter = LONGITUDE_FORMATTER
@@ -284,9 +280,12 @@ class Array_map(QtWidgets.QWidget):
        self.canvas.axes.figure.canvas.draw_idle()
    def onpick(self, event):
        btn_msg = {1: ' in selection. Aborted', 2: ' to delete a pick on. Aborted', 3: ' to display info.'}
        ind = event.ind
        button = event.mouseevent.button
-        if ind == []:
+        msg_reason = None
        if len(ind) > 1:
            self._parent.update_status(f'Found more than one station {btn_msg.get(button)}')
            return
        if button == 1:
            self.openPickDlg(ind)
@@ -389,7 +388,14 @@ class Array_map(QtWidgets.QWidget):
                try:
                    station_name = st_id.split('.')[-1]
                    # current_picks_dict: auto or manual
-                    pick = self.current_picks_dict()[station_name][phase]
+                    station_picks = self.current_picks_dict().get(station_name)
                    if not station_picks:
                        continue
                    for phase_hint, pick in station_picks.items():
                        if identifyPhaseID(phase_hint) == phase:
                            break
                    else:
                        continue
                    if pick['picker'] == 'auto':
                        if not pick['spe']:
                            continue
@@ -468,20 +474,23 @@ class Array_map(QtWidgets.QWidget):
                                                                  transform=ccrs.PlateCarree(), label='deleted'))
    def openPickDlg(self, ind):
-        data = self._parent.get_data().getWFData()
+        wfdata = self._parent.get_data().get_wf_data()
        wfdata_comp = self._parent.get_data().get_wf_dataComp()
        for index in ind:
            network, station = self._station_onpick_ids[index].split('.')[:2]
            pyl_mw = self._parent
            try:
-                data = data.select(station=station)
+                wfdata = wfdata.select(station=station)
-                if not data:
+                wfdata_comp = wfdata_comp.select(station=station)
                if not wfdata:
                    self._warn('No data for station {}'.format(station))
                    return
                pickDlg = PickDlg(self._parent, parameter=self.parameter,
-                                  data=data, network=network, station=station,
+                                  data=wfdata.copy(), data_compare=wfdata_comp.copy(), network=network, station=station,
                                  picks=self._parent.get_current_event().getPick(station),
                                  autopicks=self._parent.get_current_event().getAutopick(station),
                                  filteroptions=self._parent.filteroptions, metadata=self.metadata,
                                  model=self.parameter.get('taup_model'),
                                  event=pyl_mw.get_current_event())
            except Exception as e:
                message = 'Could not generate Plot for station {st}.\n {er}'.format(st=station, er=e)
@@ -513,7 +522,7 @@ class Array_map(QtWidgets.QWidget):
        levels = np.linspace(self.get_min_from_picks(), self.get_max_from_picks(), nlevel)
        self.contourf = self.canvas.axes.contourf(self.longrid, self.latgrid, self.picksgrid_active, levels,
-                                                  linewidths=self.linewidth*5, transform=ccrs.PlateCarree(),
+                                                  linewidths=self.linewidth * 5, transform=ccrs.PlateCarree(),
                                                  alpha=0.4, zorder=8, cmap=self.get_colormap())
    def get_colormap(self):
@@ -2,9 +2,11 @@
 # -*- coding: utf-8 -*-
 import glob
-import numpy as np
+import logging
 import os
 import sys
 import numpy as np
 from obspy import UTCDateTime, read_inventory, read
 from obspy.io.xseed import Parser
@@ -46,7 +48,7 @@ class Metadata(object):
    def __repr__(self):
        return self.__str__()
-    def add_inventory(self, path_to_inventory, obspy_dmt_inv = False):
+    def add_inventory(self, path_to_inventory, obspy_dmt_inv=False):
        """
        Add path to list of inventories.
        :param path_to_inventory: Path to a folder
@@ -188,7 +190,11 @@ class Metadata(object):
        metadata = self.get_metadata(seed_id, time)
        if not metadata:
            return
        try:
            return metadata['data'].get_coordinates(seed_id, time)
        # no specific exception defined in obspy inventory
        except Exception as e:
            logging.warning(f'Could not get metadata for {seed_id}')
    def get_all_coordinates(self):
        def stat_info_from_parser(parser):
@@ -211,6 +217,7 @@ class Metadata(object):
                        self.stations_dict[st_id] = {'latitude': station[0].latitude,
                                                     'longitude': station[0].longitude,
                                                     'elevation': station[0].elevation}
        read_stat = {'xml': stat_info_from_inventory,
                     'dless': stat_info_from_parser}
@@ -269,7 +276,7 @@ class Metadata(object):
                    continue
            invtype, robj = self._read_metadata_file(os.path.join(path_to_inventory, fname))
            try:
-                robj.get_coordinates(station_seed_id)
+                # robj.get_coordinates(station_seed_id)  # TODO: Commented out, failed with Parser, is this needed?
                self.inventory_files[fname] = {'invtype': invtype,
                                               'data': robj}
                if station_seed_id in self.seed_ids.keys():
@@ -331,19 +338,6 @@ class Metadata(object):
        return inv, exc
 def time_from_header(header):
    """
    Function takes in the second line from a .gse file and takes out the date and time from that line.
    :param header: second line from .gse file
    :type header: string
    :return: a list of integers of form [year, month, day, hour, minute, second, microsecond]
    """
    timeline = header.split(' ')
    time = timeline[1].split('/') + timeline[2].split(':')
    time = time[:-1] + time[-1].split('.')
    return [int(t) for t in time]
 def check_time(datetime):
    """
    Function takes in date and time as list and validates it's values by trying to make an UTCDateTime object from it
@@ -380,166 +374,6 @@ def check_time(datetime):
    except ValueError:
        return False
 # TODO: change root to datapath
 def get_file_list(root_dir):
    """
    Function uses a directorie to get all the *.gse files from it.
    :param root_dir: a directorie leading to the .gse files
    :type root_dir: string
    :return: returns a list of filenames (without path to them)
    """
    file_list = glob.glob1(root_dir, '*.gse')
    return file_list
 def checks_station_second(datetime, file):
    """
    Function uses the given list to check if the parameter 'second' is set to 60 by mistake
     and sets the time correctly if so. Can only correct time if no date change would be necessary.
    :param datetime: [year, month, day, hour, minute, second, microsecond]
    :return: returns the input with the correct value for second
    """
    if datetime[5] == 60:
        if datetime[4] == 59:
            if datetime[3] == 23:
                err_msg = 'Date should be next day. ' \
                          'File not changed: {0}'.format(file)
                raise ValueError(err_msg)
            else:
                datetime[3] += 1
                datetime[4] = 0
                datetime[5] = 0
        else:
            datetime[4] += 1
            datetime[5] = 0
    return datetime
 def make_time_line(line, datetime):
    """
    Function takes in the original line from a .gse file and a list of date and
    time values to make a new line with corrected date and time.
    :param line: second line from .gse file.
    :type line: string
    :param datetime: list of integers [year, month, day, hour, minute, second, microsecond]
    :type datetime: list
    :return: returns a string to write it into a file.
    """
    ins_form = '{0:02d}:{1:02d}:{2:02d}.{3:03d}'
    insertion = ins_form.format(int(datetime[3]),
                                int(datetime[4]),
                                int(datetime[5]),
                                int(datetime[6] * 1e-3))
    newline = line[:16] + insertion + line[28:]
    return newline
 def evt_head_check(root_dir, out_dir=None):
    """
    A function to make sure that an arbitrary number of .gse files have correct values in their header.
    :param root_dir: a directory leading to the .gse files.
    :type root_dir: string
    :param out_dir: a directory to store the new files somwhere els.
    :return: returns nothing
    """
    if not out_dir:
        print('WARNING files are going to be overwritten!')
        inp = str(input('Continue? [y/N]'))
        if not inp == 'y':
            sys.exit()
    filelist = get_file_list(root_dir)
    nfiles = 0
    for file in filelist:
        infile = open(os.path.join(root_dir, file), 'r')
        lines = infile.readlines()
        infile.close()
        datetime = time_from_header(lines[1])
        if check_time(datetime):
            continue
        else:
            nfiles += 1
            datetime = checks_station_second(datetime, file)
            print('writing ' + file)
            # write File
            lines[1] = make_time_line(lines[1], datetime)
            if not out_dir:
                out = open(os.path.join(root_dir, file), 'w')
                out.writelines(lines)
                out.close()
            else:
                out = open(os.path.join(out_dir, file), 'w')
                out.writelines(lines)
                out.close()
    print(nfiles)
 def read_metadata(path_to_inventory):
    """
    take path_to_inventory and return either the corresponding list of files
    found or the Parser object for a network dataless seed volume to prevent
    read overhead for large dataless seed volumes
    :param path_to_inventory:
    :return: tuple containing a either list of files or `obspy.io.xseed.Parser`
    object and the inventory type found
    :rtype: tuple
    """
    dlfile = list()
    invfile = list()
    respfile = list()
    # possible file extensions specified here:
    inv = dict(dless=dlfile, xml=invfile, resp=respfile, dseed=dlfile[:])
    if os.path.isfile(path_to_inventory):
        ext = os.path.splitext(path_to_inventory)[1].split('.')[1]
        inv[ext] += [path_to_inventory]
    else:
        for ext in inv.keys():
            inv[ext] += glob.glob1(path_to_inventory, '*.{0}'.format(ext))
    invtype = key_for_set_value(inv)
    if invtype is None:
        print("Neither dataless-SEED file, inventory-xml file nor "
              "RESP-file found!")
        print("!!WRONG CALCULATION OF SOURCE PARAMETERS!!")
        robj = None,
    elif invtype == 'dless':  # prevent multiple read of large dlsv
        print("Reading metadata information from dataless-SEED file ...")
        if len(inv[invtype]) == 1:
            fullpath_inv = os.path.join(path_to_inventory, inv[invtype][0])
            robj = Parser(fullpath_inv)
        else:
            robj = inv[invtype]
    else:
        print("Reading metadata information from inventory-xml file ...")
        robj = read_inventory(inv[invtype])
    return invtype, robj
 # idea to optimize read_metadata
 # def read_metadata_new(path_to_inventory):
 #     metadata_objects = []
 #     # read multiple files from directory
 #     if os.path.isdir(path_to_inventory):
 #         fnames = os.listdir(path_to_inventory)
 #     # read single file
 #     elif os.path.isfile(path_to_inventory):
 #         fnames = [path_to_inventory]
 #     else:
 #         print("Neither dataless-SEED file, inventory-xml file nor "
 #               "RESP-file found!")
 #         print("!!WRONG CALCULATION OF SOURCE PARAMETERS!!")
 #         fnames = []
 #
 #     for fname in fnames:
 #         path_to_inventory_filename = os.path.join(path_to_inventory, fname)
 #         try:
 #             ftype, robj = read_metadata_file(path_to_inventory_filename)
 #             metadata_objects.append((ftype, robj))
 #         except Exception as e:
 #             print('Could not read metadata file {} '
 #                   'because of the following Exception: {}'.format(path_to_inventory_filename, e))
 #     return metadata_objects
 def restitute_trace(input_tuple):
    def no_metadata(tr, seed_id):
@@ -26,9 +26,7 @@ elif system_name == "Windows":
 # suffix for phase name if not phase identified by last letter (P, p, etc.)
 ALTSUFFIX = ['diff', 'n', 'g', '1', '2', '3']
-FILTERDEFAULTS = readDefaultFilterInformation(os.path.join(os.path.expanduser('~'),
+FILTERDEFAULTS = readDefaultFilterInformation()
                                                           '.pylot',
                                                           'pylot.in'))
 TIMEERROR_DEFAULTS = os.path.join(os.path.expanduser('~'),
                                  '.pylot',
@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 import os
 from obspy import UTCDateTime
 from obspy.core.event import Event as ObsPyEvent
 from obspy.core.event import Origin, ResourceIdentifier
@@ -3,6 +3,7 @@
 # small script that creates array maps for each event within a previously generated PyLoT project
 import os
 num_thread = "16"
 os.environ["OMP_NUM_THREADS"] = num_thread
 os.environ["OPENBLAS_NUM_THREADS"] = num_thread
@@ -15,10 +16,11 @@ import multiprocessing
 import sys
 import glob
 import matplotlib
 matplotlib.use('Qt5Agg')
 sys.path.append(os.path.join('/'.join(sys.argv[0].split('/')[:-1]), '../../..'))
-from PyLoT import Project
+from pylot.core.io.project import Project
 from pylot.core.util.dataprocessing import Metadata
 from pylot.core.util.array_map import Array_map
@@ -40,7 +42,7 @@ def main(project_file_path, manual=False, auto=True, file_format='png', f_ext=''
        for item in input_list:
            array_map_worker(item)
    else:
-        pool = multiprocessing.Pool(ncores)
+        pool = multiprocessing.Pool(ncores, maxtasksperchild=1000)
        pool.map(array_map_worker, input_list)
        pool.close()
        pool.join()
@@ -52,7 +54,8 @@ def array_map_worker(input_dict):
    print('Working on event: {} ({}/{})'.format(eventdir, input_dict['index'] + 1, input_dict['nEvents']))
    xml_picks = glob.glob(os.path.join(eventdir, f'*{input_dict["f_ext"]}.xml'))
    if not len(xml_picks):
-        print('Event {} does not have any picks associated with event file extension {}'. format(eventdir, input_dict['f_ext']))
+        print('Event {} does not have any picks associated with event file extension {}'.format(eventdir,
                                                                                                input_dict['f_ext']))
        return
    # check for picks
    manualpicks = event.getPicks()
@@ -92,4 +95,3 @@ if __name__ == '__main__':
    for infile in args.infiles:
        main(os.path.join(args.dataroot, infile), f_ext='_correlated_0.03-0.1', ncores=args.ncores)
@@ -11,7 +11,6 @@ try:
 except Exception as e:
    print('Warning: Could not import module QtCore.')
 from pylot.core.util.utils import pick_color
@@ -57,7 +56,7 @@ def which(program, parameter):
        nllocpath = ":" + parameter.get('nllocbin')
        os.environ['PATH'] += nllocpath
    except Exception as e:
-        print(e.message)
+        print(e)
    def is_exe(fpath):
        return os.path.exists(fpath) and os.access(fpath, os.X_OK)
@@ -101,4 +100,3 @@ def make_pen(picktype, phase, key, quality):
        linestyle, width = pick_linestyle_pg(picktype, key)
        pen = pg.mkPen(rgba, width=width, style=linestyle)
        return pen
@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 import os
 from obspy import UTCDateTime
@@ -36,12 +37,12 @@ def qml_from_obspyDMT(path):
        return IOError('Could not find Event at {}'.format(path))
    with open(path, 'rb') as infile:
-        event_dmt = pickle.load(infile)#, fix_imports=True)
+        event_dmt = pickle.load(infile)  # , fix_imports=True)
    event_dmt['origin_id'].id = str(event_dmt['origin_id'].id)
    ev = Event(resource_id=event_dmt['event_id'])
-    #small bugfix "unhashable type: 'newstr' "
+    # small bugfix "unhashable type: 'newstr' "
    event_dmt['origin_id'].id = str(event_dmt['origin_id'].id)
    origin = Origin(resource_id=event_dmt['origin_id'],
@@ -1,8 +1,9 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 import numpy as np
 import warnings
 import numpy as np
 from obspy import UTCDateTime
 from pylot.core.util.utils import fit_curve, clims
@@ -6,7 +6,7 @@ Created on Wed Jan 26 17:47:25 2015
@author: sebastianw
 """
-from pylot.core.io.data import SeiscompDataStructure, PilotDataStructure, ObspyDMTdataStructure
+from pylot.core.io.data import SeiscompDataStructure, PilotDataStructure
 DATASTRUCTURE = {'PILOT': PilotDataStructure, 'SeisComP': SeiscompDataStructure,
-                 'obspyDMT': ObspyDMTdataStructure, None: PilotDataStructure}
+                 'obspyDMT': PilotDataStructure, None: PilotDataStructure}
@@ -1,6 +1,9 @@
 # -*- coding: utf-8 -*-
 import sys, os, traceback
 import multiprocessing
 import os
 import sys
 import traceback
 from PySide2.QtCore import QThread, Signal, Qt, Slot, QRunnable, QObject
 from PySide2.QtWidgets import QDialog, QProgressBar, QLabel, QHBoxLayout, QPushButton
@@ -19,9 +22,11 @@ class Thread(QThread):
        self.abortButton = abortButton
        self.finished.connect(self.hideProgressbar)
        self.showProgressbar()
        self.old_stdout = None
    def run(self):
        if self.redirect_stdout:
            self.old_stdout = sys.stdout
            sys.stdout = self
        try:
            if self.arg is not None:
@@ -36,7 +41,8 @@ class Thread(QThread):
            exctype, value = sys.exc_info()[:2]
            self._executedErrorInfo = '{} {} {}'. \
                format(exctype, value, traceback.format_exc())
-        sys.stdout = sys.__stdout__
+        if self.redirect_stdout:
            sys.stdout = self.old_stdout
    def showProgressbar(self):
        if self.progressText:
@@ -93,23 +99,25 @@ class Worker(QRunnable):
        self.progressText = progressText
        self.pb_widget = pb_widget
        self.redirect_stdout = redirect_stdout
        self.old_stdout = None
    @Slot()
    def run(self):
        if self.redirect_stdout:
            self.old_stdout = sys.stdout
            sys.stdout = self
        try:
            result = self.fun(self.args)
        except:
-            exctype, value = sys.exc_info ()[:2]
+            exctype, value = sys.exc_info()[:2]
            print(exctype, value, traceback.format_exc())
-            self.signals.error.emit ((exctype, value, traceback.format_exc ()))
+            self.signals.error.emit((exctype, value, traceback.format_exc()))
        else:
            self.signals.result.emit(result)
        finally:
            self.signals.finished.emit('Done')
-        sys.stdout = sys.__stdout__
+        sys.stdout = self.old_stdout
    def write(self, text):
        self.signals.message.emit(text)
@@ -141,16 +149,18 @@ class MultiThread(QThread):
        self.progressText = progressText
        self.pb_widget = pb_widget
        self.redirect_stdout = redirect_stdout
        self.old_stdout = None
        self.finished.connect(self.hideProgressbar)
        self.showProgressbar()
    def run(self):
        if self.redirect_stdout:
            self.old_stdout = sys.stdout
            sys.stdout = self
        try:
            if not self.ncores:
                self.ncores = multiprocessing.cpu_count()
-            pool = multiprocessing.Pool(self.ncores)
+            pool = multiprocessing.Pool(self.ncores, maxtasksperchild=1000)
            self.data = pool.map_async(self.func, self.args, callback=self.emitDone)
            # self.data = pool.apply_async(self.func, self.shotlist, callback=self.emitDone) #emit each time returned
            pool.close()
@@ -161,7 +171,7 @@ class MultiThread(QThread):
            exc_type, exc_obj, exc_tb = sys.exc_info()
            fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
            print('Exception: {}, file: {}, line: {}'.format(exc_type, fname, exc_tb.tb_lineno))
-        sys.stdout = sys.__stdout__
+        sys.stdout = self.old_stdout
    def showProgressbar(self):
        if self.progressText:
@@ -1,13 +1,16 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
-
+import glob
 import hashlib
-import numpy as np
+import logging
 import os
 import platform
 import re
 import subprocess
 import warnings
 from functools import lru_cache
 import numpy as np
 from obspy import UTCDateTime, read
 from obspy.core import AttribDict
 from obspy.signal.rotate import rotate2zne
@@ -17,6 +20,10 @@ from pylot.core.io.inputs import PylotParameter, FilterOptions
 from pylot.core.util.obspyDMT_interface import check_obspydmt_eventfolder
 from pylot.styles import style_settings
 Rgba: Type[tuple] = Tuple[int, int, int, int]
 Mplrgba: Type[tuple] = Tuple[float, float, float, float]
 Mplrgbastr: Type[tuple] = Tuple[str, str, str, str]
 def _pickle_method(m):
    if m.im_self is None:
@@ -36,15 +43,14 @@ def getAutoFilteroptions(phase, parameter):
    return filteroptions
-def readDefaultFilterInformation(fname):
+def readDefaultFilterInformation():
    """
    Read default filter information from pylot.in file
    :param fname: path to pylot.in file
    :type fname: str
    :return: dictionary containing the defailt filter information
    :rtype: dict
    """
-    pparam = PylotParameter(fname)
+    pparam = PylotParameter()
    pparam.reset_defaults()
    return readFilterInformation(pparam)
@@ -81,25 +87,6 @@ def fit_curve(x, y):
    return splev, splrep(x, y)
 def getindexbounds(f, eta):
    """
    Get indices of values closest below and above maximum value in an array
    :param f: array
    :type f: `~numpy.ndarray`
    :param eta: look for value in array that is closes to max_value * eta
    :type eta: float
    :return: tuple containing index of max value, index of value closest below max value,
     index of value closest above max value
    :rtype: (int, int, int)
    """
    mi = f.argmax()  # get indices of max values
    m = max(f)  # get maximum value
    b = m * eta  #
    l = find_nearest(f[:mi], b)  # find closest value below max value
    u = find_nearest(f[mi:], b) + mi  # find closest value above max value
    return mi, l, u
 def gen_Pool(ncores=0):
    """
    Generate mulitprocessing pool object utilizing ncores amount of cores
@@ -165,11 +152,11 @@ def clims(lim1, lim2):
    """
    takes two pairs of limits and returns one pair of common limts
    :param lim1: limit 1
-    :type lim1: int
+    :type lim1: List[int]
    :param lim2: limit 2
-    :type lim2: int
+    :type lim2: List[int]
    :return: new upper and lower limit common to both given limits
-    :rtype: [int, int]
+    :rtype: List[int]
    >>> clims([0, 4], [1, 3])
    [0, 4]
@@ -301,7 +288,7 @@ def fnConstructor(s):
    if type(s) is str:
        s = s.split(':')[-1]
    else:
-        s = getHash(UTCDateTime())
+        s = get_hash(UTCDateTime())
    badchars = re.compile(r'[^A-Za-z0-9_. ]+|^\.|\.$|^ | $|^$')
    badsuffix = re.compile(r'(aux|com[1-9]|con|lpt[1-9]|prn)(\.|$)')
@@ -313,32 +300,77 @@ def fnConstructor(s):
    return fn
-def get_None(value):
+def get_none(value):
    """
    Convert "None" to None
    :param value:
-    :type value: str, bool
+    :type value: str, NoneType
    :return:
-    :rtype: bool
+    :rtype: type(value) or NoneType
    >>> st = read()
    >>> print(get_none(st))
    3 Trace(s) in Stream:
    BW.RJOB..EHZ | 2009-08-24T00:20:03.000000Z - 2009-08-24T00:20:32.990000Z | 100.0 Hz, 3000 samples
    BW.RJOB..EHN | 2009-08-24T00:20:03.000000Z - 2009-08-24T00:20:32.990000Z | 100.0 Hz, 3000 samples
    BW.RJOB..EHE | 2009-08-24T00:20:03.000000Z - 2009-08-24T00:20:32.990000Z | 100.0 Hz, 3000 samples
    >>> get_none('Stream')
    'Stream'
    >>> get_none(0)
    0
    >>> get_none(0.)
    0.0
    >>> print(get_none('None'))
    None
    >>> print(get_none(None))
    None
    """
-    if value == 'None':
+    if value is None or (type(value) is str and value == 'None'):
        return None
    else:
        return value
-def get_Bool(value):
+def get_bool(value):
    """
-    Convert string representations of bools to their true boolean value
+    Convert string representations of bools to their true boolean value. Return value if it cannot be identified as bool.
    :param value:
-    :type value: str, bool
+    :type value: str, bool, int, float
    :return: true boolean value
    :rtype: bool
    >>> get_bool(True)
    True
    >>> get_bool(False)
    False
    >>> get_bool(0)
    False
    >>> get_bool(0.)
    False
    >>> get_bool(0.1)
    True
    >>> get_bool(2)
    True
    >>> get_bool(-1)
    False
    >>> get_bool(-0.3)
    False
    >>> get_bool(None)
    None
    >>> get_bool('Stream')
    'Stream'
    """
-    if value in ['True', 'true']:
+    if type(value) == bool:
        return value
    elif value in ['True', 'true']:
        return True
    elif value in ['False', 'false']:
        return False
    elif isinstance(value, float) or isinstance(value, int):
        if value > 0. or value > 0:
            return True
        else:
            return False
    else:
        return value
@@ -352,8 +384,8 @@ def four_digits(year):
    :return: four digit year correspondent
    :rtype: int
-    >>> four_digits(20)
+    >>> four_digits(75)
-    1920
+    1975
    >>> four_digits(16)
    2016
    >>> four_digits(00)
@@ -435,36 +467,53 @@ def backtransformFilterString(st):
    return st
-def getHash(time):
+def get_hash(time):
    """
    takes a time object and returns the corresponding SHA1 hash of the formatted date string
    :param time: time object for which a hash should be calculated
    :type time: `~obspy.core.utcdatetime.UTCDateTime`
    :return: SHA1 hash
    :rtype: str
    >>> time = UTCDateTime(0)
    >>> get_hash(time)
    '7627cce3b1b58dd21b005dac008b34d18317dd15'
    >>> get_hash(0)
    Traceback (most recent call last):
    ...
    AssertionError: 'time' is not an ObsPy UTCDateTime object
    """
    assert isinstance(time, UTCDateTime), '\'time\' is not an ObsPy UTCDateTime object'
    hg = hashlib.sha1()
-    hg.update(time.strftime('%Y-%m-%d %H:%M:%S.%f'))
+    hg.update(time.strftime('%Y-%m-%d %H:%M:%S.%f').encode('utf-8'))
    return hg.hexdigest()
-def getLogin():
+def get_login():
    """
-    returns the actual user's login ID
+    returns the actual user's name
-    :return: login ID
+    :return: login name
    :rtype: str
    """
    import getpass
    return getpass.getuser()
-def getOwner(fn):
+def get_owner(fn):
    """
    takes a filename and return the login ID of the actual owner of the file
    :param fn: filename of the file tested
    :type fn: str
    :return: login ID of the file's owner
    :rtype: str
    >>> import tempfile
    >>> with tempfile.NamedTemporaryFile() as tmpfile:
    ...     tmpfile.write(b'') and True
    ...     tmpfile.flush()
    ...     get_owner(tmpfile.name) == os.path.expanduser('~').split('/')[-1]
    0
    True
    """
    system_name = platform.system()
    if system_name in ["Linux", "Darwin"]:
@@ -510,6 +559,11 @@ def is_executable(fn):
    :param fn: path to the file to be tested
    :return: True or False
    :rtype: bool
    >>> is_executable('/bin/ls')
    True
    >>> is_executable('/var/log/system.log')
    False
    """
    return os.path.isfile(fn) and os.access(fn, os.X_OK)
@@ -536,24 +590,36 @@ def isSorted(iterable):
    >>> isSorted([2,3,1,4])
    False
    """
-    assert isIterable(iterable), 'object is not iterable; object: {' \
+    assert is_iterable(iterable), "object is not iterable; object: {}".format(iterable)
                                 '}'.format(iterable)
    if type(iterable) is str:
        iterable = [s for s in iterable]
    return sorted(iterable) == iterable
-def isIterable(obj):
+def is_iterable(obj):
    """
    takes a python object and returns True is the object is iterable and
    False otherwise
    :param obj: a python object
-    :type obj: object
+    :type obj: obj
    :return: True of False
    :rtype: bool
    >>> is_iterable(1)
    False
    >>> is_iterable(True)
    False
    >>> is_iterable(0.)
    False
    >>> is_iterable((0,1,3,4))
    True
    >>> is_iterable([1])
    True
    >>> is_iterable('a')
    True
    """
    try:
-        iterator = iter(obj)
+        iter(obj)
    except TypeError as te:
        return False
    return True
@@ -562,13 +628,19 @@ def isIterable(obj):
 def key_for_set_value(d):
    """
    takes a dictionary and returns the first key for which's value the
-    boolean is True
+    boolean representation is True
    :param d: dictionary containing values
    :type d: dict
    :return: key to the first non-False value found; None if no value's
    boolean equals True
-    :rtype:
+    :rtype: bool or NoneType
    >>> key_for_set_value({'one': 0, 'two': 1})
    'two'
    >>> print(key_for_set_value({1: 0, 2: False}))
    None
    """
    assert type(d) is dict, "Function only defined for inputs of type 'dict'."
    r = None
    for k, v in d.items():
        if v:
@@ -576,32 +648,53 @@ def key_for_set_value(d):
    return r
-def prepTimeAxis(stime, trace, verbosity=0):
+def prep_time_axis(offset, trace, verbosity=0):
    """
-    takes a starttime and a trace object and returns a valid time axis for
+    takes an offset and a trace object and returns a valid time axis for
    plotting
-    :param stime: start time of the actual seismogram as UTCDateTime
+    :param offset: offset of the actual seismogram on plotting axis
-    :type stime: `~obspy.core.utcdatetime.UTCDateTime`
+    :type offset: float or int
    :param trace: seismic trace object
    :type trace: `~obspy.core.trace.Trace`
    :param verbosity: if != 0, debug output will be written to console
    :type verbosity: int
    :return: valid numpy array with time stamps for plotting
    :rtype: `~numpy.ndarray`
    >>> tr = read()[0]
    >>> prep_time_axis(0., tr)
    array([0.00000000e+00, 1.00033344e-02, 2.00066689e-02, ...,
           2.99799933e+01, 2.99899967e+01, 3.00000000e+01])
    >>> prep_time_axis(22.5, tr)
    array([22.5       , 22.51000333, 22.52000667, ..., 52.47999333,
           52.48999667, 52.5       ])
    >>> prep_time_axis(tr.stats.starttime, tr)
    Traceback (most recent call last):
    ...
    AssertionError: 'offset' is not of type 'float' or 'int'; type: <class 'obspy.core.utcdatetime.UTCDateTime'>
    >>> tr.stats.npts -= 1
    >>> prep_time_axis(0, tr)
    array([0.00000000e+00, 1.00033356e-02, 2.00066711e-02, ...,
           2.99699933e+01, 2.99799967e+01, 2.99900000e+01])
    >>> tr.stats.npts += 2
    >>> prep_time_axis(0, tr)
    array([0.00000000e+00, 1.00033333e-02, 2.00066667e-02, ...,
           2.99899933e+01, 2.99999967e+01, 3.00100000e+01])
    """
    assert isinstance(offset, (float, int)), "'offset' is not of type 'float' or 'int'; type: {}".format(type(offset))
    nsamp = trace.stats.npts
    srate = trace.stats.sampling_rate
    tincr = trace.stats.delta
-    etime = stime + nsamp / srate
+    etime = offset + nsamp / srate
-    time_ax = np.linspace(stime, etime, nsamp)
+    time_ax = np.linspace(offset, etime, nsamp)
    if len(time_ax) < nsamp:
        if verbosity:
            print('elongate time axes by one datum')
-        time_ax = np.arange(stime, etime + tincr, tincr)
+        time_ax = np.arange(offset, etime + tincr, tincr)
    elif len(time_ax) > nsamp:
        if verbosity:
            print('shorten time axes by one datum')
-        time_ax = np.arange(stime, etime - tincr, tincr)
+        time_ax = np.arange(offset, etime - tincr, tincr)
    if len(time_ax) != nsamp:
        print('Station {0}, {1} samples of data \n '
              '{2} length of time vector \n'
@@ -617,13 +710,13 @@ def find_horizontals(data):
    :param data: waveform data
    :type data: `obspy.core.stream.Stream`
    :return: components list
-    :rtype: list
+    :rtype: List(str)
    ..example::
    >>> st = read()
    >>> find_horizontals(st)
-    [u'N', u'E']
+    ['N', 'E']
    """
    rval = []
    for tr in data:
@@ -634,7 +727,7 @@ def find_horizontals(data):
    return rval
-def pick_color(picktype, phase, quality=0):
+def pick_color(picktype: Literal['manual', 'automatic'], phase: Literal['P', 'S'], quality: int = 0) -> Rgba:
    """
    Create pick color by modifying the base color by the quality.
@@ -647,7 +740,7 @@ def pick_color(picktype, phase, quality=0):
    :param quality: quality of pick. Decides the new intensity of the modifier color
    :type quality: int
    :return: tuple containing modified rgba color values
-    :rtype: (int, int, int, int)
+    :rtype: Rgba
    """
    min_quality = 3
    bpc = base_phase_colors(picktype, phase)  # returns dict like {'modifier': 'g', 'rgba': (0, 0, 255, 255)}
@@ -703,17 +796,17 @@ def pick_linestyle_plt(picktype, key):
    return linestyles[picktype][key]
-def modify_rgba(rgba, modifier, intensity):
+def modify_rgba(rgba: Rgba, modifier: Literal['r', 'g', 'b'], intensity: float) -> Rgba:
    """
    Modify rgba color by adding the given intensity to the modifier color
    :param rgba: tuple containing rgba values
-    :type rgba: (int, int, int, int)
+    :type rgba: Rgba
-    :param modifier: which color should be modified, eg. 'r', 'g', 'b'
+    :param modifier: which color should be modified; options: 'r', 'g', 'b'
-    :type modifier: str
+    :type modifier: Literal['r', 'g', 'b']
    :param intensity: intensity to be added to selected color
    :type intensity: float
    :return: tuple containing rgba values
-    :rtype: (int, int, int, int)
+    :rtype: Rgba
    """
    rgba = list(rgba)
    index = {'r': 0,
@@ -747,18 +840,20 @@ def transform_colors_mpl_str(colors, no_alpha=False):
    Transforms rgba color values to a matplotlib string of color values with a range of [0, 1]
    :param colors: tuple of rgba color values ranging from [0, 255]
    :type colors: (float, float, float, float)
-    :param no_alpha: Wether to return a alpha value in the matplotlib color string
+    :param no_alpha: Whether to return an alpha value in the matplotlib color string
    :type no_alpha: bool
    :return: String containing r, g, b values and alpha value if no_alpha is False (default)
    :rtype: str
    >>> transform_colors_mpl_str((255., 255., 255., 255.), True)
    '(1.0, 1.0, 1.0)'
    >>> transform_colors_mpl_str((255., 255., 255., 255.))
    '(1.0, 1.0, 1.0, 1.0)'
    """
    colors = list(colors)
    colors_mpl = tuple([color / 255. for color in colors])
    if no_alpha:
-        colors_mpl = '({}, {}, {})'.format(*colors_mpl)
+        return '({}, {}, {})'.format(*transform_colors_mpl(colors))
    else:
-        colors_mpl = '({}, {}, {}, {})'.format(*colors_mpl)
+        return '({}, {}, {}, {})'.format(*transform_colors_mpl(colors))
    return colors_mpl
 def transform_colors_mpl(colors):
@@ -768,27 +863,16 @@ def transform_colors_mpl(colors):
    :type colors: (float, float, float, float)
    :return: tuple of rgba color values ranging from [0, 1]
    :rtype: (float, float, float, float)
    >>> transform_colors_mpl((127.5, 0., 63.75, 255.))
    (0.5, 0.0, 0.25, 1.0)
    >>> transform_colors_mpl(())
    """
    colors = list(colors)
    colors_mpl = tuple([color / 255. for color in colors])
    return colors_mpl
 def remove_underscores(data):
    """
    takes a `obspy.core.stream.Stream` object and removes all underscores
    from station names
    :param data: stream of seismic data
    :type data: `~obspy.core.stream.Stream`
    :return: data stream
    :rtype: `~obspy.core.stream.Stream`
    """
    # for tr in data:
    #    # remove underscores
    #    tr.stats.station = tr.stats.station.strip('_')
    return data
 def trim_station_components(data, trim_start=True, trim_end=True):
    """
    cut a stream so only the part common to all three traces is kept to avoid dealing with offsets
@@ -896,13 +980,53 @@ def check4doubled(data):
    return data
 def check_for_nan(data, nan_value=0.):
    """
    Replace all NaNs in data with nan_value (in place)
    :param data: stream of seismic data
    :type data: `~obspy.core.stream.Stream`
    :param nan_value: value which all NaNs are set to
    :type nan_value: float, int
    :return: None
    """
    if not data:
        return
    for trace in data:
        np.nan_to_num(trace.data, copy=False, nan=nan_value)
 def get_pylot_eventfile_with_extension(event, fext):
    if hasattr(event, 'path'):
        eventpath = event.path
    else:
        logging.warning('No attribute path found for event.')
        return
    eventname = event.pylot_id #path.split('/')[-1]  # or event.pylot_id
    filename = os.path.join(eventpath, 'PyLoT_' + eventname + fext)
    if os.path.isfile(filename):
        return filename
 def get_possible_pylot_eventfile_extensions(event, fext):
    if hasattr(event, 'path'):
        eventpath = event.path
    else:
        logging.warning('No attribute path found for event.')
        return []
    eventname = event.pylot_id
    filename = os.path.join(eventpath, 'PyLoT_' + eventname + fext)
    filenames = glob.glob(filename)
    extensions = [os.path.split(path)[-1].split('PyLoT_' + eventname)[-1] for path in filenames]
    return extensions
 def get_stations(data):
    """
-    Get list of all station names in data stream
+    Get list of all station names in data-stream
    :param data: stream containing seismic traces
    :type data: `~obspy.core.stream.Stream`
    :return: list of all station names in data, no duplicates
-    :rtype: list of str
+    :rtype: List(str)
    """
    stations = []
    for tr in data:
@@ -929,66 +1053,87 @@ def check4rotated(data, metadata=None, verbosity=1):
    :rtype: `~obspy.core.stream.Stream`
    """
-    def rotate_components(wfstream, metadata=None):
+    def rotation_required(trace_ids):
        """
        Derive if any rotation is required from the orientation code of the input.
        :param trace_ids: string identifier of waveform data trace
        :type trace_ids: List(str)
        :return: boolean representing if rotation is necessary for any of the traces
        :rtype: bool
        """
        orientations = [trace_id[-1] for trace_id in trace_ids]
        return any([orientation.isnumeric() for orientation in orientations])
    def rotate_components(wfs_in, metadata=None):
        """
        Rotate components if orientation code is numeric (= non traditional orientation).
        Azimut and dip are fetched from metadata. To be rotated, traces of a station have to be cut to the same length.
        Returns unrotated traces of no metadata is provided
-        :param wfstream: stream containing seismic traces of a station
+        :param wfs_in: stream containing seismic traces of a station
-        :type wfstream: `~obspy.core.stream.Stream`
+        :type wfs_in: `~obspy.core.stream.Stream`
        :param metadata: tuple containing metadata type string and metadata parser object
        :type metadata: (str, `~obspy.io.xseed.parser.Parser`)
        :return: stream object with traditionally oriented traces (ZNE)
        :rtype: `~obspy.core.stream.Stream`
        """
        if len(wfs_in) < 3:
            print(f"Stream {wfs_in=}, has not enough components to rotate.")
            return wfs_in
        # check if any traces in this station need to be rotated
-        trace_ids = [trace.id for trace in wfstream]
+        trace_ids = [trace.id for trace in wfs_in]
-        orientations = [trace_id[-1] for trace_id in trace_ids]
+        if not rotation_required(trace_ids):
-        rotation_required = [orientation.isnumeric() for orientation in orientations]
+            logging.debug(f"Stream does not need any rotation: Traces are {trace_ids=}")
-        if any(rotation_required):
+            return wfs_in
-            t_start = full_range(wfstream)
+
        # check metadata quality
        t_start = full_range(wfs_in)
        try:
-                azimuts = []
+            azimuths = []
            dips = []
            for tr_id in trace_ids:
-                    azimuts.append(metadata.get_coordinates(tr_id, t_start)['azimuth'])
+                azimuths.append(metadata.get_coordinates(tr_id, t_start)['azimuth'])
                dips.append(metadata.get_coordinates(tr_id, t_start)['dip'])
-            except (KeyError, TypeError) as e:
+        except (KeyError, TypeError) as err:
-                print('Failed to rotate trace {}, no azimuth or dip available in metadata'.format(tr_id))
+            logging.error(f"{type(err)=} occurred: {err=} Rotating not possible, not all azimuth and dip information "
-                return wfstream
+                  f"available in metadata. Stream remains unchanged.")
-            if len(wfstream) < 3:
+            return wfs_in
-                print('Failed to rotate Stream {}, not enough components available.'.format(wfstream))
+        except Exception as err:
-                return wfstream
+            print(f"Unexpected {err=}, {type(err)=}")
            raise
        # to rotate all traces must have same length, so trim them
-            wfstream = trim_station_components(wfstream, trim_start=True, trim_end=True)
+        wfs_out = trim_station_components(wfs_in, trim_start=True, trim_end=True)
        try:
-                z, n, e = rotate2zne(wfstream[0], azimuts[0], dips[0],
+            z, n, e = rotate2zne(wfs_out[0], azimuths[0], dips[0],
-                                     wfstream[1], azimuts[1], dips[1],
+                                 wfs_out[1], azimuths[1], dips[1],
-                                     wfstream[2], azimuts[2], dips[2])
+                                 wfs_out[2], azimuths[2], dips[2])
            print('check4rotated: rotated trace {} to ZNE'.format(trace_ids))
            # replace old data with rotated data, change the channel code to ZNE
            z_index = dips.index(min(
-                    dips))  # get z-trace index, z has minimum dip of -90 (dip is measured from 0 to -90, with -90 being vertical)
+                dips))  # get z-trace index, z has minimum dip of -90 (dip is measured from 0 to -90, with -90
-                wfstream[z_index].data = z
+            # being vertical)
-                wfstream[z_index].stats.channel = wfstream[z_index].stats.channel[0:-1] + 'Z'
+            wfs_out[z_index].data = z
            wfs_out[z_index].stats.channel = wfs_out[z_index].stats.channel[0:-1] + 'Z'
            del trace_ids[z_index]
            for trace_id in trace_ids:
                coordinates = metadata.get_coordinates(trace_id, t_start)
                dip, az = coordinates['dip'], coordinates['azimuth']
-                    trace = wfstream.select(id=trace_id)[0]
+                trace = wfs_out.select(id=trace_id)[0]
-                    if az > 315 or az <= 45 or az > 135 and az <= 225:
+                if az > 315 or az <= 45 or 135 < az <= 225:
                    trace.data = n
                    trace.stats.channel = trace.stats.channel[0:-1] + 'N'
-                    elif az > 45 and az <= 135 or az > 225 and az <= 315:
+                elif 45 < az <= 135 or 225 < az <= 315:
                    trace.data = e
                    trace.stats.channel = trace.stats.channel[0:-1] + 'E'
-            except (ValueError) as e:
+        except ValueError as err:
-                print(e)
+            print(f"{err=} Rotation failed. Stream remains unchanged.")
-                return wfstream
+            return wfs_in
-        return wfstream
+        return wfs_out
    if metadata is None:
        if verbosity:
@@ -1002,38 +1147,6 @@ def check4rotated(data, metadata=None, verbosity=1):
    return data
 def scaleWFData(data, factor=None, components='all'):
    """
    produce scaled waveforms from given waveform data and a scaling factor,
    waveform may be selected by their components name
    :param data: waveform data to be scaled
    :type data: `~obspy.core.stream.Stream` object
    :param factor: scaling factor
    :type factor: float
    :param components: components labels for the traces in data to be scaled by
     the scaling factor (optional, default: 'all')
    :type components: tuple
    :return:  scaled waveform data
    :rtype: `~obspy.core.stream.Stream` object
    """
    if components != 'all':
        for comp in components:
            if factor is None:
                max_val = np.max(np.abs(data.select(component=comp)[0].data))
                data.select(component=comp)[0].data /= 2 * max_val
            else:
                data.select(component=comp)[0].data /= 2 * factor
    else:
        for tr in data:
            if factor is None:
                max_val = float(np.max(np.abs(tr.data)))
                tr.data /= 2 * max_val
            else:
                tr.data /= 2 * factor
    return data
 def runProgram(cmd, parameter=None):
    """
    run an external program specified by cmd with parameters input returning the
@@ -1168,7 +1281,7 @@ def correct_iplot(iplot):
    try:
        iplot = int(iplot)
    except ValueError:
-        if get_Bool(iplot):
+        if get_bool(iplot):
            iplot = 2
        else:
            iplot = 0
@@ -35,9 +35,9 @@ from __future__ import print_function
 __all__ = "get_git_version"
 import inspect
 # NO IMPORTS FROM PYLOT IN THIS FILE! (file gets used at installation time)
 import os
 import inspect
 from subprocess import Popen, PIPE
 # NO IMPORTS FROM PYLOT IN THIS FILE! (file gets used at installation time)
@@ -0,0 +1,9 @@
 # This file may be used to create an environment using:
 # $ conda create --name <env> --file <this file>
 # platform: win-64
 cartopy>=0.20.2
 numpy<2
 obspy>=1.3.0
 pyqtgraph>=0.12.4
 pyside2>=5.13.2
 scipy>=1.8.0
@@ -1,17 +0,0 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 from distutils.core import setup
 setup(
    name='PyLoT',
    version='0.2',
    packages=['pylot', 'pylot.core', 'pylot.core.loc', 'pylot.core.pick',
              'pylot.core.io', 'pylot.core.util', 'pylot.core.active',
              'pylot.core.analysis', 'pylot.testing'],
    requires=['obspy', 'PySide2', 'matplotlib', 'numpy', 'scipy', 'pyqtgraph', 'cartopy'],
    url='dummy',
    license='LGPLv3',
    author='Sebastian Wehling-Benatelli',
    author_email='sebastian.wehling@rub.de',
    description='Comprehensive Python picking and Location Toolbox for seismological data.'
 )
@@ -1,6 +1,8 @@
 import unittest
 from pylot.core.pick.autopick import PickingResults
 class TestPickingResults(unittest.TestCase):
    def setUp(self):
@@ -70,9 +72,9 @@ class TestPickingResults(unittest.TestCase):
            curr_len = len(self.pr)
        except Exception:
            self.fail("test_dunder_attributes overwrote an instance internal dunder method")
-        self.assertEqual(prev_len+1, curr_len)        # +1 for the added __len__ key/value-pair
+        self.assertEqual(prev_len + 1, curr_len)  # +1 for the added __len__ key/value-pair
        self.pr.__len__ = 42
        self.assertEqual(42, self.pr['__len__'])
-        self.assertEqual(prev_len+1, curr_len, msg="__len__ was overwritten")
+        self.assertEqual(prev_len + 1, curr_len, msg="__len__ was overwritten")
@@ -1,5 +1,6 @@
 import os
 import unittest
 from obspy import UTCDateTime
 from obspy.io.xseed import Parser
 from obspy.io.xseed.utils import SEEDParserException
@@ -27,7 +28,7 @@ class TestMetadata(unittest.TestCase):
        result = {}
        for channel in ('Z', 'N', 'E'):
            with HidePrints():
-                coords = self.m.get_coordinates(self.station_id+channel, time=self.time)
+                coords = self.m.get_coordinates(self.station_id + channel, time=self.time)
            result[channel] = coords
            self.assertDictEqual(result[channel], expected[channel])
@@ -42,7 +43,7 @@ class TestMetadata(unittest.TestCase):
        result = {}
        for channel in ('Z', 'N', 'E'):
            with HidePrints():
-                coords = self.m.get_coordinates(self.station_id+channel)
+                coords = self.m.get_coordinates(self.station_id + channel)
            result[channel] = coords
            self.assertDictEqual(result[channel], expected[channel])
@@ -145,7 +146,7 @@ class TestMetadata_read_single_file(unittest.TestCase):
    def test_read_single_file(self):
        """Test if reading a single file works"""
-        fname = os.path.join(self.metadata_folders[0], 'DATALESS.'+self.station_id)
+        fname = os.path.join(self.metadata_folders[0], 'DATALESS.' + self.station_id)
        with HidePrints():
            res = self.m.read_single_file(fname)
        # method should return true if file is successfully read
@@ -172,7 +173,7 @@ class TestMetadata_read_single_file(unittest.TestCase):
    def test_read_single_file_multiple_times(self):
        """Test if reading a file twice doesnt add it twice to the metadata object"""
-        fname = os.path.join(self.metadata_folders[0], 'DATALESS.'+self.station_id)
+        fname = os.path.join(self.metadata_folders[0], 'DATALESS.' + self.station_id)
        with HidePrints():
            res1 = self.m.read_single_file(fname)
            res2 = self.m.read_single_file(fname)
@@ -197,7 +198,8 @@ class TestMetadataMultipleTime(unittest.TestCase):
    def setUp(self):
        self.seed_id = 'LE.ROTT..HN'
        path = os.path.dirname(__file__)  # gets path to currently running script
-        metadata = os.path.join('test_data', 'dless_multiple_times', 'MAGS2_LE_ROTT.dless')  # specific subfolder of test data
+        metadata = os.path.join('test_data', 'dless_multiple_times',
                                'MAGS2_LE_ROTT.dless')  # specific subfolder of test data
        metadata_path = os.path.join(path, metadata)
        self.m = Metadata(metadata_path)
        self.p = Parser(metadata_path)
@@ -299,7 +301,8 @@ Channels:
    def setUp(self):
        self.seed_id = 'KB.TMO07.00.HHZ'
        path = os.path.dirname(__file__)  # gets path to currently running script
-        metadata = os.path.join('test_data', 'dless_multiple_instruments', 'MAGS2_KB_TMO07.dless')  # specific subfolder of test data
+        metadata = os.path.join('test_data', 'dless_multiple_instruments',
                                'MAGS2_KB_TMO07.dless')  # specific subfolder of test data
        metadata_path = os.path.join(path, metadata)
        self.m = Metadata(metadata_path)
        self.p = Parser(metadata_path)
@@ -1,12 +1,13 @@
 import unittest
 from unittest import skip
 import obspy
 from obspy import UTCDateTime
 import os
 import sys
-from pylot.core.pick.autopick import autopickstation
+import unittest
-from pylot.core.io.inputs import PylotParameter
+
 import obspy
 from obspy import UTCDateTime
 from pylot.core.io.data import Data
 from pylot.core.io.inputs import PylotParameter
 from pylot.core.pick.autopick import autopickstation
 from pylot.core.util.utils import trim_station_components
@@ -93,51 +94,100 @@ class TestAutopickStation(unittest.TestCase):
        self.inputfile_taupy_disabled = os.path.join(os.path.dirname(__file__), 'autoPyLoT_global_taupy_false.in')
        self.pickparam_taupy_enabled = PylotParameter(fnin=self.inputfile_taupy_enabled)
        self.pickparam_taupy_disabled = PylotParameter(fnin=self.inputfile_taupy_disabled)
-        self.xml_file = os.path.join(os.path.dirname(__file__),self.event_id, 'PyLoT_'+self.event_id+'.xml')
+        self.xml_file = os.path.join(os.path.dirname(__file__), self.event_id, 'PyLoT_' + self.event_id + '.xml')
        self.data = Data(evtdata=self.xml_file)
        # create origin for taupy testing
-        self.origin = [obspy.core.event.origin.Origin(magnitude=7.1, latitude=59.66, longitude=-153.45, depth=128.0, time=UTCDateTime("2016-01-24T10:30:30.0"))]
+        self.origin = [obspy.core.event.origin.Origin(magnitude=7.1, latitude=59.66, longitude=-153.45, depth=128.0,
                                                      time=UTCDateTime("2016-01-24T10:30:30.0"))]
        # mocking metadata since reading it takes a long time to read from file
        self.metadata = MockMetadata()
        # show complete diff when difference in results dictionaries are found
        self.maxDiff = None
-    #@skip("Works")
+    # @skip("Works")
    def test_autopickstation_taupy_disabled_gra1(self):
-        expected = {'P': {'picker': 'auto', 'snrdb': 15.405649120980094, 'weight': 0, 'Mo': None, 'marked': [], 'Mw': None, 'fc': None, 'snr': 34.718816470730317, 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 31, 690000), 'w0': None, 'spe': 0.93333333333333235, 'network': u'GR', 'epp': UTCDateTime(2016, 1, 24, 10, 41, 28, 890000), 'lpp': UTCDateTime(2016, 1, 24, 10, 41, 32, 690000), 'fm': 'D', 'channel': u'LHZ'}, 'S': {'picker': 'auto', 'snrdb': 10.669661906545489, 'network': u'GR', 'weight': 0, 'Ao': None, 'lpp': UTCDateTime(2016, 1, 24, 10, 50, 30, 690000), 'snr': 11.667187857573905, 'epp': UTCDateTime(2016, 1, 24, 10, 50, 21, 690000), 'mpp': UTCDateTime(2016, 1, 24, 10, 50, 29, 690000), 'fm': None, 'spe': 2.6666666666666665, 'channel': u'LHE'}}
+        expected = {
            'P': {'picker': 'auto', 'snrdb': 15.405649120980094, 'weight': 0, 'Mo': None, 'marked': [], 'Mw': None,
                  'fc': None, 'snr': 34.718816470730317, 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 31, 690000),
                  'w0': None, 'spe': 0.93333333333333235, 'network': u'GR',
                  'epp': UTCDateTime(2016, 1, 24, 10, 41, 28, 890000),
                  'lpp': UTCDateTime(2016, 1, 24, 10, 41, 32, 690000), 'fm': 'D', 'channel': u'LHZ'},
            'S': {'picker': 'auto', 'snrdb': 10.669661906545489, 'network': u'GR', 'weight': 0, 'Ao': None,
                  'lpp': UTCDateTime(2016, 1, 24, 10, 50, 30, 690000), 'snr': 11.667187857573905,
                  'epp': UTCDateTime(2016, 1, 24, 10, 50, 21, 690000),
                  'mpp': UTCDateTime(2016, 1, 24, 10, 50, 29, 690000), 'fm': None, 'spe': 2.6666666666666665,
                  'channel': u'LHE'}}
        with HidePrints():
-            result, station = autopickstation(wfstream=self.gra1, pickparam=self.pickparam_taupy_disabled, metadata=(None, None))
+            result, station = autopickstation(wfstream=self.gra1, pickparam=self.pickparam_taupy_disabled,
                                              metadata=(None, None))
        self.assertDictContainsSubset(expected=expected['P'], actual=result['P'])
        self.assertDictContainsSubset(expected=expected['S'], actual=result['S'])
        self.assertEqual('GRA1', station)
    def test_autopickstation_taupy_enabled_gra1(self):
-        expected = {'P': {'picker': 'auto', 'snrdb': 15.599905299126778, 'weight': 0, 'Mo': None, 'marked': [], 'Mw': None, 'fc': None, 'snr': 36.307013769185403, 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 27, 690000), 'w0': None, 'spe': 0.93333333333333235, 'network': u'GR', 'epp': UTCDateTime(2016, 1, 24, 10, 41, 24, 890000), 'lpp': UTCDateTime(2016, 1, 24, 10, 41, 28, 690000), 'fm': 'U', 'channel': u'LHZ'}, 'S': {'picker': 'auto', 'snrdb': 10.669661906545489, 'network': u'GR', 'weight': 0, 'Ao': None, 'lpp': UTCDateTime(2016, 1, 24, 10, 50, 30, 690000), 'snr': 11.667187857573905, 'epp': UTCDateTime(2016, 1, 24, 10, 50, 21, 690000), 'mpp': UTCDateTime(2016, 1, 24, 10, 50, 29, 690000), 'fm': None, 'spe': 2.6666666666666665, 'channel': u'LHE'}}
+        expected = {
            'P': {'picker': 'auto', 'snrdb': 15.599905299126778, 'weight': 0, 'Mo': None, 'marked': [], 'Mw': None,
                  'fc': None, 'snr': 36.307013769185403, 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 27, 690000),
                  'w0': None, 'spe': 0.93333333333333235, 'network': u'GR',
                  'epp': UTCDateTime(2016, 1, 24, 10, 41, 24, 890000),
                  'lpp': UTCDateTime(2016, 1, 24, 10, 41, 28, 690000), 'fm': 'U', 'channel': u'LHZ'},
            'S': {'picker': 'auto', 'snrdb': 10.669661906545489, 'network': u'GR', 'weight': 0, 'Ao': None,
                  'lpp': UTCDateTime(2016, 1, 24, 10, 50, 30, 690000), 'snr': 11.667187857573905,
                  'epp': UTCDateTime(2016, 1, 24, 10, 50, 21, 690000),
                  'mpp': UTCDateTime(2016, 1, 24, 10, 50, 29, 690000), 'fm': None, 'spe': 2.6666666666666665,
                  'channel': u'LHE'}}
        with HidePrints():
-            result, station = autopickstation(wfstream=self.gra1, pickparam=self.pickparam_taupy_enabled, metadata=self.metadata, origin=self.origin)
+            result, station = autopickstation(wfstream=self.gra1, pickparam=self.pickparam_taupy_enabled,
                                              metadata=self.metadata, origin=self.origin)
        self.assertDictContainsSubset(expected=expected['P'], actual=result['P'])
        self.assertDictContainsSubset(expected=expected['S'], actual=result['S'])
        self.assertEqual('GRA1', station)
    def test_autopickstation_taupy_disabled_gra2(self):
-        expected = {'P': {'picker': 'auto', 'snrdb': None, 'weight': 9, 'Mo': None, 'marked': 'shortsignallength', 'Mw': None, 'fc': None, 'snr': None, 'mpp': UTCDateTime(2016, 1, 24, 10, 36, 59, 150000), 'w0': None, 'spe': None, 'network': u'GR', 'epp': UTCDateTime(2016, 1, 24, 10, 36, 43, 150000), 'lpp': UTCDateTime(2016, 1, 24, 10, 37, 15, 150000), 'fm': 'N', 'channel': u'LHZ'}, 'S': {'picker': 'auto', 'snrdb': None, 'network': u'GR', 'weight': 4, 'Ao': None, 'lpp': UTCDateTime(2016, 1, 24, 10, 37, 15, 150000), 'snr': None, 'epp': UTCDateTime(2016, 1, 24, 10, 36, 43, 150000), 'mpp': UTCDateTime(2016, 1, 24, 10, 36, 59, 150000), 'fm': None, 'spe': None, 'channel': u'LHE'}}
+        expected = {
            'P': {'picker': 'auto', 'snrdb': None, 'weight': 9, 'Mo': None, 'marked': 'shortsignallength', 'Mw': None,
                  'fc': None, 'snr': None, 'mpp': UTCDateTime(2016, 1, 24, 10, 36, 59, 150000), 'w0': None, 'spe': None,
                  'network': u'GR', 'epp': UTCDateTime(2016, 1, 24, 10, 36, 43, 150000),
                  'lpp': UTCDateTime(2016, 1, 24, 10, 37, 15, 150000), 'fm': 'N', 'channel': u'LHZ'},
            'S': {'picker': 'auto', 'snrdb': None, 'network': u'GR', 'weight': 4, 'Ao': None,
                  'lpp': UTCDateTime(2016, 1, 24, 10, 37, 15, 150000), 'snr': None,
                  'epp': UTCDateTime(2016, 1, 24, 10, 36, 43, 150000),
                  'mpp': UTCDateTime(2016, 1, 24, 10, 36, 59, 150000), 'fm': None, 'spe': None, 'channel': u'LHE'}}
        with HidePrints():
-            result, station = autopickstation(wfstream=self.gra2, pickparam=self.pickparam_taupy_disabled, metadata=(None, None))
+            result, station = autopickstation(wfstream=self.gra2, pickparam=self.pickparam_taupy_disabled,
                                              metadata=(None, None))
        self.assertDictContainsSubset(expected=expected['P'], actual=result['P'])
        self.assertDictContainsSubset(expected=expected['S'], actual=result['S'])
        self.assertEqual('GRA2', station)
    def test_autopickstation_taupy_enabled_gra2(self):
-        expected = {'P': {'picker': 'auto', 'snrdb': 13.957959025719253, 'weight': 0, 'Mo': None, 'marked': [], 'Mw': None, 'fc': None, 'snr': 24.876879503607871, 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 29, 150000), 'w0': None, 'spe': 1.0, 'network': u'GR', 'epp': UTCDateTime(2016, 1, 24, 10, 41, 26, 150000), 'lpp': UTCDateTime(2016, 1, 24, 10, 41, 30, 150000), 'fm': None, 'channel': u'LHZ'}, 'S': {'picker': 'auto', 'snrdb': 10.573236990555648, 'network': u'GR', 'weight': 1, 'Ao': None, 'lpp': UTCDateTime(2016, 1, 24, 10, 50, 34, 150000), 'snr': 11.410999834108294, 'epp': UTCDateTime(2016, 1, 24, 10, 50, 21, 150000), 'mpp': UTCDateTime(2016, 1, 24, 10, 50, 33, 150000), 'fm': None, 'spe': 4.666666666666667, 'channel': u'LHE'}}
+        expected = {
            'P': {'picker': 'auto', 'snrdb': 13.957959025719253, 'weight': 0, 'Mo': None, 'marked': [], 'Mw': None,
                  'fc': None, 'snr': 24.876879503607871, 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 29, 150000),
                  'w0': None, 'spe': 1.0, 'network': u'GR', 'epp': UTCDateTime(2016, 1, 24, 10, 41, 26, 150000),
                  'lpp': UTCDateTime(2016, 1, 24, 10, 41, 30, 150000), 'fm': None, 'channel': u'LHZ'},
            'S': {'picker': 'auto', 'snrdb': 10.573236990555648, 'network': u'GR', 'weight': 1, 'Ao': None,
                  'lpp': UTCDateTime(2016, 1, 24, 10, 50, 34, 150000), 'snr': 11.410999834108294,
                  'epp': UTCDateTime(2016, 1, 24, 10, 50, 21, 150000),
                  'mpp': UTCDateTime(2016, 1, 24, 10, 50, 33, 150000), 'fm': None, 'spe': 4.666666666666667,
                  'channel': u'LHE'}}
        with HidePrints():
-            result, station = autopickstation(wfstream=self.gra2, pickparam=self.pickparam_taupy_enabled, metadata=self.metadata, origin = self.origin)
+            result, station = autopickstation(wfstream=self.gra2, pickparam=self.pickparam_taupy_enabled,
                                              metadata=self.metadata, origin=self.origin)
        self.assertDictContainsSubset(expected=expected['P'], actual=result['P'])
        self.assertDictContainsSubset(expected=expected['S'], actual=result['S'])
        self.assertEqual('GRA2', station)
    def test_autopickstation_taupy_disabled_ech(self):
-        expected = {'P': {'picker': 'auto', 'snrdb': None, 'weight': 9, 'Mo': None, 'marked': 'SinsteadP', 'Mw': None, 'fc': None, 'snr': None, 'mpp': UTCDateTime(2016, 1, 24, 10, 26, 57), 'w0': None, 'spe': None, 'network': u'G', 'epp': UTCDateTime(2016, 1, 24, 10, 26, 41), 'lpp': UTCDateTime(2016, 1, 24, 10, 27, 13), 'fm': 'N', 'channel': u'LHZ'}, 'S': {'picker': 'auto', 'snrdb': None, 'network': u'G', 'weight': 4, 'Ao': None, 'lpp': UTCDateTime(2016, 1, 24, 10, 27, 13), 'snr': None, 'epp': UTCDateTime(2016, 1, 24, 10, 26, 41), 'mpp': UTCDateTime(2016, 1, 24, 10, 26, 57), 'fm': None, 'spe': None, 'channel': u'LHE'}}
+        expected = {'P': {'picker': 'auto', 'snrdb': None, 'weight': 9, 'Mo': None, 'marked': 'SinsteadP', 'Mw': None,
                          'fc': None, 'snr': None, 'mpp': UTCDateTime(2016, 1, 24, 10, 26, 57), 'w0': None, 'spe': None,
                          'network': u'G', 'epp': UTCDateTime(2016, 1, 24, 10, 26, 41),
                          'lpp': UTCDateTime(2016, 1, 24, 10, 27, 13), 'fm': 'N', 'channel': u'LHZ'},
                    'S': {'picker': 'auto', 'snrdb': None, 'network': u'G', 'weight': 4, 'Ao': None,
                          'lpp': UTCDateTime(2016, 1, 24, 10, 27, 13), 'snr': None,
                          'epp': UTCDateTime(2016, 1, 24, 10, 26, 41), 'mpp': UTCDateTime(2016, 1, 24, 10, 26, 57),
                          'fm': None, 'spe': None, 'channel': u'LHE'}}
        with HidePrints():
            result, station = autopickstation(wfstream=self.ech, pickparam=self.pickparam_taupy_disabled)
        self.assertDictContainsSubset(expected=expected['P'], actual=result['P'])
@@ -146,16 +196,32 @@ class TestAutopickStation(unittest.TestCase):
    def test_autopickstation_taupy_enabled_ech(self):
        # this station has a long time of before the first onset, so taupy will help during picking
-        expected = {'P': {'picker': 'auto', 'snrdb': 9.9753586609166316, 'weight': 0, 'Mo': None, 'marked': [], 'Mw': None, 'fc': None, 'snr': 9.9434218804137107, 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 34), 'w0': None, 'spe': 1.6666666666666667, 'network': u'G', 'epp': UTCDateTime(2016, 1, 24, 10, 41, 29), 'lpp': UTCDateTime(2016, 1, 24, 10, 41, 35), 'fm': None, 'channel': u'LHZ'}, 'S': {'picker': 'auto', 'snrdb': 12.698999454169567, 'network': u'G', 'weight': 0, 'Ao': None, 'lpp': UTCDateTime(2016, 1, 24, 10, 50, 44), 'snr': 18.616581906366577, 'epp': UTCDateTime(2016, 1, 24, 10, 50, 33), 'mpp': UTCDateTime(2016, 1, 24, 10, 50, 43), 'fm': None, 'spe': 3.3333333333333335, 'channel': u'LHE'}}
+        expected = {
            'P': {'picker': 'auto', 'snrdb': 9.9753586609166316, 'weight': 0, 'Mo': None, 'marked': [], 'Mw': None,
                  'fc': None, 'snr': 9.9434218804137107, 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 34), 'w0': None,
                  'spe': 1.6666666666666667, 'network': u'G', 'epp': UTCDateTime(2016, 1, 24, 10, 41, 29),
                  'lpp': UTCDateTime(2016, 1, 24, 10, 41, 35), 'fm': None, 'channel': u'LHZ'},
            'S': {'picker': 'auto', 'snrdb': 12.698999454169567, 'network': u'G', 'weight': 0, 'Ao': None,
                  'lpp': UTCDateTime(2016, 1, 24, 10, 50, 44), 'snr': 18.616581906366577,
                  'epp': UTCDateTime(2016, 1, 24, 10, 50, 33), 'mpp': UTCDateTime(2016, 1, 24, 10, 50, 43), 'fm': None,
                  'spe': 3.3333333333333335, 'channel': u'LHE'}}
        with HidePrints():
-            result, station = autopickstation(wfstream=self.ech, pickparam=self.pickparam_taupy_enabled, metadata=self.metadata, origin=self.origin)
+            result, station = autopickstation(wfstream=self.ech, pickparam=self.pickparam_taupy_enabled,
                                              metadata=self.metadata, origin=self.origin)
        self.assertDictContainsSubset(expected=expected['P'], actual=result['P'])
        self.assertDictContainsSubset(expected=expected['S'], actual=result['S'])
        self.assertEqual('ECH', station)
    def test_autopickstation_taupy_disabled_fiesa(self):
        # this station has a long time of before the first onset, so taupy will help during picking
-        expected = {'P': {'picker': 'auto', 'snrdb': None, 'weight': 9, 'Mo': None, 'marked': 'SinsteadP', 'Mw': None, 'fc': None, 'snr': None, 'mpp': UTCDateTime(2016, 1, 24, 10, 35, 58), 'w0': None, 'spe': None, 'network': u'CH', 'epp': UTCDateTime(2016, 1, 24, 10, 35, 42), 'lpp': UTCDateTime(2016, 1, 24, 10, 36, 14), 'fm': 'N', 'channel': u'LHZ'}, 'S': {'picker': 'auto', 'snrdb': None, 'network': u'CH', 'weight': 4, 'Ao': None, 'lpp': UTCDateTime(2016, 1, 24, 10, 36, 14), 'snr': None, 'epp': UTCDateTime(2016, 1, 24, 10, 35, 42), 'mpp': UTCDateTime(2016, 1, 24, 10, 35, 58), 'fm': None, 'spe': None, 'channel': u'LHE'}}
+        expected = {'P': {'picker': 'auto', 'snrdb': None, 'weight': 9, 'Mo': None, 'marked': 'SinsteadP', 'Mw': None,
                          'fc': None, 'snr': None, 'mpp': UTCDateTime(2016, 1, 24, 10, 35, 58), 'w0': None, 'spe': None,
                          'network': u'CH', 'epp': UTCDateTime(2016, 1, 24, 10, 35, 42),
                          'lpp': UTCDateTime(2016, 1, 24, 10, 36, 14), 'fm': 'N', 'channel': u'LHZ'},
                    'S': {'picker': 'auto', 'snrdb': None, 'network': u'CH', 'weight': 4, 'Ao': None,
                          'lpp': UTCDateTime(2016, 1, 24, 10, 36, 14), 'snr': None,
                          'epp': UTCDateTime(2016, 1, 24, 10, 35, 42), 'mpp': UTCDateTime(2016, 1, 24, 10, 35, 58),
                          'fm': None, 'spe': None, 'channel': u'LHE'}}
        with HidePrints():
            result, station = autopickstation(wfstream=self.fiesa, pickparam=self.pickparam_taupy_disabled)
        self.assertDictContainsSubset(expected=expected['P'], actual=result['P'])
@@ -164,9 +230,18 @@ class TestAutopickStation(unittest.TestCase):
    def test_autopickstation_taupy_enabled_fiesa(self):
        # this station has a long time of before the first onset, so taupy will help during picking
-        expected = {'P': {'picker': 'auto', 'snrdb': 13.921049277904373, 'weight': 0, 'Mo': None, 'marked': [], 'Mw': None, 'fc': None, 'snr': 24.666352170589487, 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 47), 'w0': None, 'spe': 1.2222222222222285, 'network': u'CH', 'epp': UTCDateTime(2016, 1, 24, 10, 41, 43, 333333), 'lpp': UTCDateTime(2016, 1, 24, 10, 41, 48), 'fm': None, 'channel': u'LHZ'}, 'S': {'picker': 'auto', 'snrdb': 10.893086316477728, 'network': u'CH', 'weight': 0, 'Ao': None, 'lpp': UTCDateTime(2016, 1, 24, 10, 51, 5), 'snr': 12.283118216397849, 'epp': UTCDateTime(2016, 1, 24, 10, 50, 59, 333333), 'mpp': UTCDateTime(2016, 1, 24, 10, 51, 2), 'fm': None, 'spe': 2.8888888888888764, 'channel': u'LHE'}}
+        expected = {
            'P': {'picker': 'auto', 'snrdb': 13.921049277904373, 'weight': 0, 'Mo': None, 'marked': [], 'Mw': None,
                  'fc': None, 'snr': 24.666352170589487, 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 47), 'w0': None,
                  'spe': 1.2222222222222285, 'network': u'CH', 'epp': UTCDateTime(2016, 1, 24, 10, 41, 43, 333333),
                  'lpp': UTCDateTime(2016, 1, 24, 10, 41, 48), 'fm': None, 'channel': u'LHZ'},
            'S': {'picker': 'auto', 'snrdb': 10.893086316477728, 'network': u'CH', 'weight': 0, 'Ao': None,
                  'lpp': UTCDateTime(2016, 1, 24, 10, 51, 5), 'snr': 12.283118216397849,
                  'epp': UTCDateTime(2016, 1, 24, 10, 50, 59, 333333), 'mpp': UTCDateTime(2016, 1, 24, 10, 51, 2),
                  'fm': None, 'spe': 2.8888888888888764, 'channel': u'LHE'}}
        with HidePrints():
-            result, station = autopickstation(wfstream=self.fiesa, pickparam=self.pickparam_taupy_enabled, metadata=self.metadata, origin=self.origin)
+            result, station = autopickstation(wfstream=self.fiesa, pickparam=self.pickparam_taupy_enabled,
                                              metadata=self.metadata, origin=self.origin)
        self.assertDictContainsSubset(expected=expected['P'], actual=result['P'])
        self.assertDictContainsSubset(expected=expected['S'], actual=result['S'])
        self.assertEqual('FIESA', station)
@@ -176,7 +251,8 @@ class TestAutopickStation(unittest.TestCase):
        wfstream = self.gra1.copy()
        wfstream = wfstream.select(channel='*E') + wfstream.select(channel='*N')
        with HidePrints():
-            result, station = autopickstation(wfstream=wfstream, pickparam=self.pickparam_taupy_disabled, metadata=(None, None))
+            result, station = autopickstation(wfstream=wfstream, pickparam=self.pickparam_taupy_disabled,
                                              metadata=(None, None))
        self.assertIsNone(result)
        self.assertEqual('GRA1', station)
@@ -184,17 +260,36 @@ class TestAutopickStation(unittest.TestCase):
        """Picking on a stream without horizontal traces should still pick the P phase on the vertical component"""
        wfstream = self.gra1.copy()
        wfstream = wfstream.select(channel='*Z')
-        expected =  {'P': {'picker': 'auto', 'snrdb': 15.405649120980094, 'network': u'GR', 'weight': 0, 'Ao': None, 'Mo': None, 'marked': [], 'lpp': UTCDateTime(2016, 1, 24, 10, 41, 32, 690000), 'Mw': None, 'fc': None, 'snr': 34.718816470730317, 'epp': UTCDateTime(2016, 1, 24, 10, 41, 28, 890000), 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 31, 690000), 'w0': None, 'spe': 0.9333333333333323, 'fm': 'D', 'channel': u'LHZ'}, 'S': {'picker': 'auto', 'snrdb': None, 'network': None, 'weight': 4, 'Mo': None, 'Ao': None, 'lpp': None, 'Mw': None, 'fc': None, 'snr': None, 'marked': [], 'mpp': None, 'w0': None, 'spe': None, 'epp': None, 'fm': 'N', 'channel': None}}
+        expected = {
            'P': {'picker': 'auto', 'snrdb': 15.405649120980094, 'network': u'GR', 'weight': 0, 'Ao': None, 'Mo': None,
                  'marked': [], 'lpp': UTCDateTime(2016, 1, 24, 10, 41, 32, 690000), 'Mw': None, 'fc': None,
                  'snr': 34.718816470730317, 'epp': UTCDateTime(2016, 1, 24, 10, 41, 28, 890000),
                  'mpp': UTCDateTime(2016, 1, 24, 10, 41, 31, 690000), 'w0': None, 'spe': 0.9333333333333323, 'fm': 'D',
                  'channel': u'LHZ'},
            'S': {'picker': 'auto', 'snrdb': None, 'network': None, 'weight': 4, 'Mo': None, 'Ao': None, 'lpp': None,
                  'Mw': None, 'fc': None, 'snr': None, 'marked': [], 'mpp': None, 'w0': None, 'spe': None, 'epp': None,
                  'fm': 'N', 'channel': None}}
        with HidePrints():
-            result, station = autopickstation(wfstream=wfstream, pickparam=self.pickparam_taupy_disabled, metadata=(None, None))
+            result, station = autopickstation(wfstream=wfstream, pickparam=self.pickparam_taupy_disabled,
                                              metadata=(None, None))
        self.assertEqual(expected, result)
        self.assertEqual('GRA1', station)
    def test_autopickstation_a106_taupy_enabled(self):
        """This station has invalid values recorded on both N and E component, but a pick can still be found on Z"""
-        expected = {'P': {'picker': 'auto', 'snrdb': 12.862128789922826, 'network': u'Z3', 'weight': 0, 'Ao': None, 'Mo': None, 'marked': [], 'lpp': UTCDateTime(2016, 1, 24, 10, 41, 34), 'Mw': None, 'fc': None, 'snr': 19.329155459132608, 'epp': UTCDateTime(2016, 1, 24, 10, 41, 30), 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 33), 'w0': None, 'spe': 1.6666666666666667, 'fm': None, 'channel': u'LHZ'}, 'S': {'picker': 'auto', 'snrdb': None, 'network': u'Z3', 'weight': 4, 'Ao': None, 'Mo': None, 'marked': [], 'lpp': UTCDateTime(2016, 1, 24, 10, 28, 56), 'Mw': None, 'fc': None, 'snr': None, 'epp': UTCDateTime(2016, 1, 24, 10, 28, 24), 'mpp': UTCDateTime(2016, 1, 24, 10, 28, 40), 'w0': None, 'spe': None, 'fm': None, 'channel': u'LHE'}}
+        expected = {
            'P': {'picker': 'auto', 'snrdb': 12.862128789922826, 'network': u'Z3', 'weight': 0, 'Ao': None, 'Mo': None,
                  'marked': [], 'lpp': UTCDateTime(2016, 1, 24, 10, 41, 34), 'Mw': None, 'fc': None,
                  'snr': 19.329155459132608, 'epp': UTCDateTime(2016, 1, 24, 10, 41, 30),
                  'mpp': UTCDateTime(2016, 1, 24, 10, 41, 33), 'w0': None, 'spe': 1.6666666666666667, 'fm': None,
                  'channel': u'LHZ'},
            'S': {'picker': 'auto', 'snrdb': None, 'network': u'Z3', 'weight': 4, 'Ao': None, 'Mo': None, 'marked': [],
                  'lpp': UTCDateTime(2016, 1, 24, 10, 28, 56), 'Mw': None, 'fc': None, 'snr': None,
                  'epp': UTCDateTime(2016, 1, 24, 10, 28, 24), 'mpp': UTCDateTime(2016, 1, 24, 10, 28, 40), 'w0': None,
                  'spe': None, 'fm': None, 'channel': u'LHE'}}
        with HidePrints():
-            result, station = autopickstation(wfstream=self.a106, pickparam=self.pickparam_taupy_enabled, metadata=self.metadata, origin=self.origin)
+            result, station = autopickstation(wfstream=self.a106, pickparam=self.pickparam_taupy_enabled,
                                              metadata=self.metadata, origin=self.origin)
        self.assertEqual(expected, result)
    def test_autopickstation_station_missing_in_metadata(self):
@@ -202,10 +297,22 @@ class TestAutopickStation(unittest.TestCase):
        relative to the theoretical onset to one relative to the traces starttime, eg never negative.
        """
        self.pickparam_taupy_enabled.setParamKV('pstart', -100)  # modify starttime to be relative to theoretical onset
-        expected = {'P': {'picker': 'auto', 'snrdb': 14.464757855513506, 'network': u'Z3', 'weight': 0, 'Mo': None, 'Ao': None, 'lpp': UTCDateTime(2016, 1, 24, 10, 41, 39, 605000), 'Mw': None, 'fc': None, 'snr': 27.956048519707181, 'marked': [], 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 38, 605000), 'w0': None, 'spe': 1.6666666666666667, 'epp': UTCDateTime(2016, 1, 24, 10, 41, 35, 605000), 'fm': None, 'channel': u'LHZ'}, 'S': {'picker': 'auto', 'snrdb': 10.112844176301248, 'network': u'Z3', 'weight': 1, 'Mo': None, 'Ao': None, 'lpp': UTCDateTime(2016, 1, 24, 10, 50, 51, 605000), 'Mw': None, 'fc': None, 'snr': 10.263238413785425, 'marked': [], 'mpp': UTCDateTime(2016, 1, 24, 10, 50, 48, 605000), 'w0': None, 'spe': 4.666666666666667, 'epp': UTCDateTime(2016, 1, 24, 10, 50, 40, 605000), 'fm': None, 'channel': u'LHE'}}
+        expected = {
            'P': {'picker': 'auto', 'snrdb': 14.464757855513506, 'network': u'Z3', 'weight': 0, 'Mo': None, 'Ao': None,
                  'lpp': UTCDateTime(2016, 1, 24, 10, 41, 39, 605000), 'Mw': None, 'fc': None,
                  'snr': 27.956048519707181, 'marked': [], 'mpp': UTCDateTime(2016, 1, 24, 10, 41, 38, 605000),
                  'w0': None, 'spe': 1.6666666666666667, 'epp': UTCDateTime(2016, 1, 24, 10, 41, 35, 605000),
                  'fm': None, 'channel': u'LHZ'},
            'S': {'picker': 'auto', 'snrdb': 10.112844176301248, 'network': u'Z3', 'weight': 1, 'Mo': None, 'Ao': None,
                  'lpp': UTCDateTime(2016, 1, 24, 10, 50, 51, 605000), 'Mw': None, 'fc': None,
                  'snr': 10.263238413785425, 'marked': [], 'mpp': UTCDateTime(2016, 1, 24, 10, 50, 48, 605000),
                  'w0': None, 'spe': 4.666666666666667, 'epp': UTCDateTime(2016, 1, 24, 10, 50, 40, 605000), 'fm': None,
                  'channel': u'LHE'}}
        with HidePrints():
-            result, station = autopickstation(wfstream = self.a005a, pickparam=self.pickparam_taupy_enabled, metadata=self.metadata, origin=self.origin)
+            result, station = autopickstation(wfstream=self.a005a, pickparam=self.pickparam_taupy_enabled,
                                              metadata=self.metadata, origin=self.origin)
        self.assertEqual(expected, result)
 if __name__ == '__main__':
    unittest.main()
@@ -0,0 +1,33 @@
 import unittest
 from pylot.core.io.phases import getQualitiesfromxml
 class TestQualityFromXML(unittest.TestCase):
    def setUp(self):
        self.path = '.'
        self.ErrorsP = [0.02, 0.04, 0.08, 0.16]
        self.ErrorsS = [0.04, 0.08, 0.16, 0.32]
        self.test0_result = [[0.0136956521739, 0.0126, 0.0101612903226, 0.00734848484849, 0.0135069444444,
                              0.00649659863946, 0.0129513888889, 0.0122747747748, 0.0119252873563, 0.0103947368421,
                              0.0092380952381, 0.00916666666667, 0.0104444444444, 0.0125333333333, 0.00904761904762,
                              0.00885714285714, 0.00911616161616, 0.0164166666667, 0.0128787878788, 0.0122756410256,
                              0.013653253667966917], [0.0239333333333, 0.0223791578953, 0.0217974304255],
                             [0.0504861111111, 0.0610833333333], [], [0.171029411765]], [
                                [0.0195, 0.0203623188406, 0.0212121212121, 0.0345833333333, 0.0196180555556,
                                 0.0202536231884, 0.0200347222222, 0.0189, 0.0210763888889, 0.018275862069,
                                 0.0213888888889, 0.0319791666667, 0.0205303030303, 0.0156388888889, 0.0192,
                                 0.0231349206349, 0.023625, 0.02875, 0.0195512820513, 0.0239393939394, 0.0234166666667,
                                 0.0174702380952, 0.0204151307995], [0.040314343081226646], [0.148555555556], [], []]
        self.test1_result = [77.77777777777777, 11.11111111111111, 7.407407407407407, 0, 3.7037037037037037],\
                            [92.0, 4.0, 4.0, 0, 0]
    def test_result_plotflag0(self):
        self.assertEqual(getQualitiesfromxml(self.path, self.ErrorsP, self.ErrorsS, 0), self.test0_result)
    def test_result_plotflag1(self):
        self.assertEqual(getQualitiesfromxml(self.path, self.ErrorsP, self.ErrorsS, 1), self.test1_result)
 if __name__ == '__main__':
    unittest.main()
@@ -1,4 +1,5 @@
 import unittest
 from pylot.core.pick.utils import get_quality_class
@@ -52,5 +53,6 @@ class TestQualityClassFromUncertainty(unittest.TestCase):
        # Error exactly in class 3
        self.assertEqual(3, get_quality_class(5.6, self.error_classes))
 if __name__ == '__main__':
    unittest.main()
@@ -33,6 +33,7 @@ class HidePrints:
        def silencer(*args, **kwargs):
            with HidePrints():
                func(*args, **kwargs)
        return silencer
    def __init__(self, hide_prints=True):
Author	SHA1	Message	Date
Wehling-Benatelli	e434bda993	[change] corrected for required versions	2024-08-30 15:01:28 +02:00
sebastianw	c0c3cbbd7b	refactor: remove unused methods	2024-08-30 15:01:28 +02:00
sebastianw	76d4ec290c	refactor: restructure data objects	2024-08-30 15:01:18 +02:00
sebastianw	63dac0fff6	refactor: restructure data objects	2024-08-30 15:00:44 +02:00
sebastianw	b15cfe2e1d	bugfix: corrected for ValueError	2024-08-30 15:00:44 +02:00
sebastianw	29a1e4ebe6	refactor: move Project definition to individual file	2024-08-30 14:59:28 +02:00
sebastianw	50cabb0038	refactor: remove unused code; rewrite too complex functions	2024-08-30 14:59:28 +02:00
sebastianw	8dd5789b0c	refactor: remove unnecessary additional declaration	2024-08-30 14:59:28 +02:00
sebastianw	c4aeab0d89	suggestion: add new dataclasses; remove unused code	2024-08-30 14:59:19 +02:00
sebastianw	ef69fc429f	refactor: removed unused code	2024-08-30 14:58:53 +02:00
sebastianw	c8f9c1c33a	refactor: rename writephases; add write hash to write_phases	2024-08-30 14:58:53 +02:00
sebastianw	59f2c4b46f	refactor: remove unused code; restructure writephases	2024-08-30 14:58:53 +02:00
sebastianw	8eb958c91b	change: add docu and test case	2024-08-30 14:58:52 +02:00
marcel	6b7f297d7a	[update] adding possibility to display other waveform data (e.g. denoised/synthetic) together with genuine data for comparison	2024-08-30 14:58:38 +02:00
marcel	70d5c2d621	[minor] mpl.figure.canvas.draw -> draw_idle	2024-08-30 12:03:14 +02:00
marcel	7393201b90	[minor] inform if station coordinates were not found in metadata	2024-08-30 12:03:14 +02:00
marcel	d02f74ab10	[bugfix] added missing Parameter object in call for picksdict_from_picks	2024-08-30 12:03:14 +02:00
marcel	0a5f5f0817	[minor] removed unneeded imports	2024-08-30 12:03:05 +02:00
marcel	db976e5ea9	[bugfix] removing redundancy and wrong bullsh.. try-except code	2024-08-30 12:02:22 +02:00
marcel	c021ca19d7	[minor] switch default cmap for array_map to 'viridis'	2024-08-30 12:02:22 +02:00
marcel	356988e71d	[update] further improved Pickfile selection dialog, now providing methods "overwrite" or "merge"	2024-08-30 12:02:22 +02:00
marcel	ad62284e0e	[update] improve pickfile selection, give the ability to select only specific files	2024-08-30 12:02:06 +02:00
marcel	0fb0b0f11c	[bugfix] re-implement ability of get_bool to return unidentifiable input	2024-08-30 11:59:50 +02:00
sebastianw	e3dd4a4e28	bugfix: remove unused functions; correct for wrong formatting (PEP)	2024-08-30 11:59:49 +02:00
sebastianw	2bbb84190c	feat: add type hints and tests for plot utils	2024-08-30 11:56:59 +02:00
sebastianw	fb32d5e0c5	bugfix: add tests to key_for_set_value	2024-08-30 11:55:14 +02:00
sebastianw	f043401cc0	bugfix: rename is_iterable and add doc tests	2024-08-30 11:55:14 +02:00
sebastianw	eb15382b5f	bugfix: refactor get_owner and get_hash; add tests	2024-08-30 11:55:13 +02:00
sebastianw	7fbc3bc5ae	bugfix: add new tests and refactor get_none	2024-08-30 11:55:01 +02:00
sebastianw	221743fe20	bugfix: correct erroneous and add new doctests	2024-08-30 11:49:22 +02:00
sebastianw	554afc5a81	bugfix: update check4rotate	2024-08-29 16:12:19 +02:00
marcel	c79e886d77	[minor] update default shell script for SGE	2024-06-06 15:55:47 +02:00
marcel	76f2d5d972	[update] improve SearchForFileExtensionDialog now proposing available file endings	2024-06-06 15:54:36 +02:00
marcel	2d08fd029d	[hotfix] datetime formatting caused error when time not set	2024-06-06 13:55:11 +02:00
marcel	8f22d438d3	[update] changed eventbox overview to show P and S onsets separately	2024-06-05 16:18:25 +02:00
marcel	93b7de3baa	[update] raising PickingFailedException when CF cannot be calculated due to missing signal (too short waveform) [update] raising PickingFailedException when CF cannot be calculated due to missing signal (too short waveform)	2024-06-05 14:31:09 +02:00
marcel	05642e775b	[minor] some tweaks (convenience) [update] raising PickingFailedException when CF cannot be calculated due to missing signal (too short waveform)	2024-06-05 14:31:07 +02:00
marcel	47205ca493	[update] improved calculation of smoothed AIC. Old code always created an artificial value and a np.nan at the array start	2024-06-05 14:31:07 +02:00
marcel	5c7f0b56eb	[update] improved SearchFileByExtensionDialog widget	2024-06-05 14:19:17 +02:00
marcel	c574031931	[bugfix] the implementation approach of STA/LTA inside characteristic function calculation (skewness/kurtosis) corrupted the old, working code due to a mistake in the logic	2024-06-05 14:17:57 +02:00
marcel	e1a0fde619	[update] improved array map to identify and display other phase names than P / S	2024-05-29 11:43:31 +02:00
marcel	48d196df11	[update] improved SearchFileByExtensionDialog widget (table, auto refresh)	2024-05-29 11:42:10 +02:00
marcel	6cc9cb4a96	[minor] reduced maxtasksperchild for multiprocessing	2024-05-29 11:40:34 +02:00
marcel	5eab686445	[bugfix] accidentally removed return value	2024-05-24 16:10:32 +02:00
marcel	b12e7937ac	[update] added a widget for loading pick files that lists available files depending on chosen filemask	2024-05-22 10:58:07 +02:00
marcel	78f2dbcab2	[update] added check for nan values in waveforms which crashed obspy filter routines [minor] some tweaks and optimisations	2024-04-30 15:48:54 +02:00
marcel	8b95c7a0fe	[update] changed sorting of traces overview if all station names are numeric (e.g. active experiments)	2024-04-09 16:02:31 +02:00
marcel	f03ace75e7	[bugfix] QWidget.show() killed figure axis dimensions creating unexpected error of fig.aspect=0 when creating colorbar inset_axes in Python 3.11	2024-03-22 17:10:04 +01:00
marcel	9c78471d20	[bugfix] header resize method renamed in QT5	2024-03-22 15:34:05 +01:00
marcel	09d2fb1022	[bugfix] pt2 of fmpicker fix, make sure to also copy stream in autoPyLoT closes #24	2023-08-24 12:55:30 +02:00
marcel	3cae6d3a78	[bugfix] use copies of wfdata when calling fmpicker to prevent modification of actual data used inside GUI	2023-08-24 11:28:30 +02:00
marcel	2e85d083a3	[bugfix] do not call calcsourcespec if incidence angle is outside bounds (for whatever reason)	2023-08-24 11:27:30 +02:00
marcel	ba4e6cfe50	[bugfix] bin directory + /bin creates "/bin/bin". Also it is not taken care of os compatibility and also compatibility with existing code (line 86ff was useless after recent change in line 85)	2023-08-23 14:48:21 +02:00
marcel	1f16d01648	[minor] give more precise user warning if no pick channel was selected	2023-08-23 09:38:16 +02:00
marcel	3069e7d526	[minor] commented - possibly unnecessary - line of code that created an error when using old metadata Parser	2023-08-22 15:53:49 +02:00
marcel	a9aeb7aaa3	[bugfix] set simple phase hint (P or S)	2023-08-22 15:53:49 +02:00
marcel	b9adb182ad	[bugfix] could not handle asterisk-marked events when opening tune-autopicker	2023-08-22 15:53:49 +02:00
marcel	a823eb2440	[workaround] using explicit Exception definition without a special handling does not make sense. Function broke on other errors in polyfit. Still might need fixes in the two lines above the "except" block(s).	2023-08-22 15:53:49 +02:00
marcel	486e3dc9c3	Merge pull request 'Disabled button in case flag is false' (#31 ) from disable-show-log-widget into develop Reviewed-on: #31	2023-08-22 12:05:33 +02:00
marcel	8d356050d7	[update] corrected original authors of PILOT	2023-08-22 12:01:51 +02:00
jeldrik	43cab3767f	[Bugfix] fixxed wrong check for taupymodel	2023-06-27 08:04:00 +02:00
jeldrik	a1f6c5ffca	Bugfixxes, spectogram tab wip	2023-06-14 13:11:54 +02:00
jeldrik	e4e7afa996	Minor changes to adjust to python 3. Temporary Fix for file exporting not working properly. WIP spectrogram view.	2023-04-27 10:24:55 +02:00
sebastianw	0634d24814	fix: disabled button in case flag is false The button was not disabled in case the flag variable was false. The get_Bool function was renamed and improved to also work in case in the input variable is of type int or float. Additionally, the environment file was corrected to also work for macOS installations with ARM architecture.	2023-04-06 16:40:20 +02:00
jeldrik	43c2b97b3d	Small changes	2023-01-24 11:45:12 +01:00
ann-christin	8d94440e77	[bugfix] logwidget always initiated	2022-11-14 14:14:59 +01:00
ann-christin	66b7dea706	[update] pylot.in no longer mandatory	2022-11-14 14:14:12 +01:00
ann-christin	ebf6d4806a	[minor] reformating	2022-11-14 11:52:25 +01:00
ann-christin	207d0b3a6f	[update] directly pass args from arg parser	2022-11-14 11:18:15 +01:00
ann-christin	3b3bbc29d1	Merge remote-tracking branch 'origin/develop' into develop	2022-11-14 10:30:38 +01:00
jeldrik	0c3fca9299	Re-Added local changes that had been lost due to technical problems ( no access to old machine )	2022-10-04 11:44:31 +02:00
jeldrik	2d33a60421	[Bugfix] Multiple small bugfixxes keeping NLL from working in python3.+	2022-09-15 14:31:13 +02:00
ann-christin	a8c6f4c972	[reformat] spell checking	2022-08-25 15:31:08 +02:00
ann-christin	0d91f9e3fe	update github link	2022-08-25 14:03:05 +02:00
ann-christin	494d281d61	update github link	2022-08-25 14:00:37 +02:00
kaan	5ef427ec12	Merge branch 'develop' of git.geophysik.ruhr-uni-bochum.de:marcel/pylot into develop	2022-06-29 14:07:35 +02:00
kaan	29cf978782	minor bug fixes	2022-06-29 14:07:06 +02:00
marcel	091449819c	[update] tau-p usage for s-picking	2022-05-31 18:16:02 +02:00
marcel	cd9c139349	[bugfix] mainly added missing taup model (lost in branch merging for python3), some smaller fixes for S picking	2022-05-31 12:45:22 +02:00
marcel	084fb10cea	Merge remote-tracking branch 'origin/develop' into develop	2022-05-31 09:59:17 +02:00
marcel	dde9520879	[minor] deactivate logwidget by default as it seems to irregularly create segfaults	2022-05-31 09:40:15 +02:00
marcel	7847f40a35	[minor] added developers do README	2022-04-01 12:07:51 +02:00
ludger	2c188432a1	Merge branch 'develop' of https://git.geophysik.ruhr-uni-bochum.de/marcel/pylot into develop	2022-03-24 13:28:52 +01:00
marcel	86dc0f5436	[minor] small style changes	2022-03-22 11:26:29 +01:00
marcel	83ba63a3fd	Merge pull request 'feature/port-to-py3' (#11 ) from feature/port-to-py3 into develop Reviewed-on: #11	2022-03-21 15:30:05 +01:00
ludger	3392100206	Removed psd	2022-03-17 13:42:27 +01:00
marcel	401265eb3a	[minor] added some comments	2022-03-16 16:03:54 +01:00
marcel	dd685d5d5e	[refactor] rewrote/simplified getQualitiesfromxml code, used function already implemented in phases.py	2022-03-16 16:00:14 +01:00
marcel	3cd17ff364	[update] added xml file for unittest	2022-03-16 14:31:03 +01:00
marcel	d879aa1a8b	[bugfix] small fix to get getQualitiesfromxml running, added unittest for function	2022-03-16 14:29:47 +01:00
marcel	445f1da5ac	[bugfix] reset stdout to previously set one and not to default sys.__stdout__	2022-03-16 09:25:28 +01:00
marcel	962cf4edac	[minor] README.md	2022-03-15 11:14:08 +01:00
marcel	eb0dd87a9e	[update] optimize requirements/yml file	2022-03-15 10:44:37 +01:00
marcel	e9cc579cf6	[minor] README.md	2022-03-15 10:41:48 +01:00
marcel	f1fd52b750	[bugfix] when closing mainwindow, also close logwidget	2022-03-15 10:41:29 +01:00
marcel	5449210797	[update] optimize requirements/yml file	2022-03-15 10:12:39 +01:00
marcel	0af948030b	[bugfix] chooseArrival -> chooseArrivals, fixes #25	2022-03-15 09:42:25 +01:00
marcel	21b1be0e56	[update] updated README	2022-03-14 16:05:58 +01:00
marcel	58eee13b07	[update] removed setup.py (deprecated)	2022-03-14 15:53:42 +01:00
marcel	c57eb4f556	[update] added requirements, updated pylot.yml and setup.py	2022-03-14 15:33:33 +01:00
marcel	47bb8c4326	Merge branch 'develop' into feature/port-to-py3	2022-03-14 13:19:20 +01:00
marcel	29ffcf2e37	[bugfix] pick_r unreferenced, closes #26	2022-03-14 11:18:51 +01:00
marcel	e35d5d6df9	[refactor] automatic code reformatting (Pycharm)	2022-03-09 14:41:34 +01:00
marcel	79f3d40714	[refactor] code cleanup (WIP)	2022-03-09 14:28:30 +01:00