Merge branch 'develop' into improve-util-utils

PyLoT.py

@@ -72,11 +72,11 @@ from pylot.core.util.errors import DatastructureError, \
     OverwriteError
 from pylot.core.util.connection import checkurl
 from pylot.core.util.dataprocessing import Metadata, restitute_data
-from pylot.core.util.utils import fnConstructor, getLogin, \
+from pylot.core.util.utils import fnConstructor, get_login, \
     full_range, readFilterInformation, pick_color_plt, \
     pick_linestyle_plt, identifyPhaseID, excludeQualityClasses, \
     transform_colors_mpl, transform_colors_mpl_str, getAutoFilteroptions, check_all_obspy, \
-    check_all_pylot, get_bool, get_None
+    check_all_pylot, get_bool, get_none
 from pylot.core.util.gui import make_pen
 from pylot.core.util.event import Event
 from pylot.core.io.location import create_creation_info, create_event
@@ -181,7 +181,6 @@ class MainWindow(QMainWindow):
         self.autodata = Data(self)
 
         self.fnames = None
-        self.fnames_comp = None
         self._stime = None
 
         # track deleted picks for logging
@@ -197,7 +196,7 @@ class MainWindow(QMainWindow):
                 if settings.value("user/FullName", None) is None:
                     fulluser = QInputDialog.getText(self, "Enter Name:", "Full name")
                     settings.setValue("user/FullName", fulluser)
-                    settings.setValue("user/Login", getLogin())
+                    settings.setValue("user/Login", get_login())
                 if settings.value("agency_id", None) is None:
                     agency = QInputDialog.getText(self,
                                                   "Enter authority/institution name:",
@@ -509,8 +508,6 @@ class MainWindow(QMainWindow):
         logAction = self.createAction(self, "&Show Log", self.showLogWidget,
                                       tip="""Display Log""")
 
-        logAction.setEnabled(use_logwidget)
-
         # create button group for component selection
 
         componentGroup = QActionGroup(self)
@@ -1131,19 +1128,16 @@ class MainWindow(QMainWindow):
             else:
                 return
 
-    def getWFFnames_from_eventbox(self, eventbox: str = None, subpath: str = None) -> list:
+    def getWFFnames_from_eventbox(self, eventbox=None):
         '''
         Return waveform filenames from event in eventbox.
         '''
         # TODO: add dataStructure class for obspyDMT here, this is just a workaround!
         eventpath = self.get_current_event_path(eventbox)
-        if subpath:
-            eventpath = os.path.join(eventpath, subpath)
-        if not os.path.isdir(eventpath):
-            return []
+        basepath = eventpath.split(os.path.basename(eventpath))[0]
         if self.dataStructure:
             if not eventpath:
-                return []
+                return
             fnames = [os.path.join(eventpath, f) for f in os.listdir(eventpath)]
         else:
             raise DatastructureError('not specified')
@@ -1388,7 +1382,7 @@ class MainWindow(QMainWindow):
         index = eventBox.currentIndex()
         tv = QtWidgets.QTableView()
         header = tv.horizontalHeader()
-        header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+        header.setResizeMode(QtWidgets.QHeaderView.ResizeToContents)
         header.setStretchLastSection(True)
         header.hide()
         tv.verticalHeader().hide()
@@ -1955,20 +1949,13 @@ class MainWindow(QMainWindow):
 
     def prepareLoadWaveformData(self):
         self.fnames = self.getWFFnames_from_eventbox()
-        self.fnames_comp = []
-        fnames_comp = self.getWFFnames_from_eventbox(subpath='compare')
-        self.dataPlot.activateCompareOptions(bool(fnames_comp))
-        if fnames_comp:
-            if self.dataPlot.comp_checkbox.isChecked():
-                self.fnames_comp = fnames_comp
-
+        self.fnames_syn = []
         eventpath = self.get_current_event_path()
         basepath = eventpath.split(os.path.basename(eventpath))[0]
         self.obspy_dmt = check_obspydmt_structure(basepath)
         self.dataPlot.activateObspyDMToptions(self.obspy_dmt)
         if self.obspy_dmt:
             self.prepareObspyDMT_data(eventpath)
-            self.dataPlot.activateCompareOptions(True)
 
     def loadWaveformData(self):
         '''
@@ -1990,8 +1977,8 @@ class MainWindow(QMainWindow):
 
         if len(curr_event.origins) > 0:
             origin_time = curr_event.origins[0].time
-            tstart = settings.value('tstart') if get_None(settings.value('tstart')) else 0
-            tstop = settings.value('tstop') if get_None(settings.value('tstop')) else 0
+            tstart = settings.value('tstart') if get_none(settings.value('tstart')) else 0
+            tstop = settings.value('tstop') if get_none(settings.value('tstop')) else 0
             tstart = origin_time + float(tstart)
             tstop = origin_time + float(tstop)
         else:
@@ -1999,7 +1986,7 @@ class MainWindow(QMainWindow):
             tstop = None
 
         self.data.setWFData(self.fnames,
-                            self.fnames_comp,
+                            self.fnames_syn,
                             checkRotated=True,
                             metadata=self.metadata,
                             tstart=tstart,
@@ -2007,7 +1994,7 @@ class MainWindow(QMainWindow):
 
     def prepareObspyDMT_data(self, eventpath):
         qcbox_processed = self.dataPlot.qcombo_processed
-        qcheckb_syn = self.dataPlot.comp_checkbox
+        qcheckb_syn = self.dataPlot.syn_checkbox
         qcbox_processed.setEnabled(False)
         qcheckb_syn.setEnabled(False)
         for fpath in os.listdir(eventpath):
@@ -2015,8 +2002,8 @@ class MainWindow(QMainWindow):
             if 'syngine' in fpath:
                 eventpath_syn = os.path.join(eventpath, fpath)
                 qcheckb_syn.setEnabled(True)
-                if self.dataPlot.comp_checkbox.isChecked():
-                    self.fnames_comp = [os.path.join(eventpath_syn, filename) for filename in os.listdir(eventpath_syn)]
+                if self.dataPlot.syn_checkbox.isChecked():
+                    self.fnames_syn = [os.path.join(eventpath_syn, filename) for filename in os.listdir(eventpath_syn)]
             if 'processed' in fpath:
                 qcbox_processed.setEnabled(True)
         if qcbox_processed.isEnabled():
@@ -2297,7 +2284,7 @@ class MainWindow(QMainWindow):
         comp = self.getComponent()
         title = 'section: {0} components'.format(zne_text[comp])
         wfst = self.get_data().getWFData()
-        wfsyn = self.get_data().getAltWFdata()
+        wfsyn = self.get_data().getSynWFData()
         if self.filterActionP.isChecked() and filter:
             self.filterWaveformData(plot=False, phase='P')
         elif self.filterActionS.isChecked() and filter:
@@ -2306,7 +2293,7 @@ class MainWindow(QMainWindow):
         # wfst += self.get_data().getWFData().select(component=alter_comp)
         plotWidget = self.getPlotWidget()
         self.adjustPlotHeight()
-        if get_bool(settings.value('large_dataset')):
+        if get_bool(settings.value('large_dataset')) == True:
             self.plot_method = 'fast'
         else:
             self.plot_method = 'normal'
@@ -2609,21 +2596,18 @@ class MainWindow(QMainWindow):
             print("Warning! No network, station, and location info available!")
             return
         self.update_status('picking on station {0}'.format(station))
-        wfdata = self.get_data().getOriginalWFData().copy()
-        wfdata_comp = self.get_data().getAltWFdata().copy()
+        data = self.get_data().getOriginalWFData().copy()
         event = self.get_current_event()
         wftype = self.dataPlot.qcombo_processed.currentText() if self.obspy_dmt else None
         pickDlg = PickDlg(self, parameter=self._inputs,
-                          data=wfdata.select(station=station),
-                          data_compare=wfdata_comp.select(station=station),
+                          data=data.select(station=station),
                           station=station, network=network,
                           location=location,
                           picks=self.getPicksOnStation(station, 'manual'),
                           autopicks=self.getPicksOnStation(station, 'auto'),
                           metadata=self.metadata, event=event,
                           model=self.inputs.get('taup_model'),
-                          filteroptions=self.filteroptions, wftype=wftype,
-                          show_comp_data=self.dataPlot.comp_checkbox.isChecked())
+                          filteroptions=self.filteroptions, wftype=wftype)
         if self.filterActionP.isChecked():
             pickDlg.currentPhase = "P"
             pickDlg.filterWFData()
@@ -3473,7 +3457,7 @@ class MainWindow(QMainWindow):
                     self.event_table.setCellWidget(r_index, c_index, item)
 
         header = self.event_table.horizontalHeader()
-        header.setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+        header.setResizeMode(QtWidgets.QHeaderView.ResizeToContents)
         header.setStretchLastSection(True)
         self.event_table.cellChanged[int, int].connect(cell_changed)
         self.event_table.cellClicked[int, int].connect(cell_clicked)

README.md

@@ -99,7 +99,7 @@ We hope to solve these with the next release.
 
 ## Staff
 
-Original author(s): M. Rische, S. Wehling-Benatelli, L. Kueperkoch, M. Bischoff (PILOT)
+Original author(s): L. Kueperkoch, S. Wehling-Benatelli, M. Bischoff (PILOT)
 
 Developer(s): S. Wehling-Benatelli, M. Paffrath, L. Kueperkoch, K. Olbert, M. Bischoff, C. Wollin, M. Rische, D. Arnold, K. Cökerim, S. Zimmermann
 

autoPyLoT.py

@@ -28,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
 
@@ -91,9 +91,9 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even
                                                               sp=sp_info)
     print(splash)
 
-    parameter = get_None(parameter)
-    inputfile = get_None(inputfile)
-    eventid = get_None(eventid)
+    parameter = get_none(parameter)
+    inputfile = get_none(inputfile)
+    eventid = get_none(eventid)
 
     fig_dict = None
     fig_dict_wadatijack = None
@@ -154,7 +154,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')

autopylot.sh

@@ -7,6 +7,4 @@
 #$ -l h_vmem=2G
 #$ -l os=*stretch
 
-conda activate pylot_38
-
-python ./autoPyLoT.py -i /home/marcel/.pylot/pylot_janis_noisy.in -c $NSLOTS
+python ./autoPyLoT.py -i /home/marcel/.pylot/pylot_alparray_mantle_corr_stack_0.03-0.5.in -dmt processed -c $NSLOTS

pylot.yml

@@ -8,7 +8,7 @@ dependencies:
   - numpy=1.22.3
   - obspy=1.3.0
   - pyqtgraph=0.12.4
-  - pyside2>=5.13.2
+  - pyside2=5.13.2
   - python=3.8.12
-  - qt>=5.12.9
+  - qt=5.12.9
   - scipy=1.8.0

pylot/core/analysis/magnitude.py

@@ -418,10 +418,6 @@ 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)

pylot/core/io/data.py

@@ -451,25 +451,20 @@ class Data(object):
         data.filter(**kwargs)
         self.dirty = True
 
-    def setWFData(self, fnames, fnames_alt=None, checkRotated=False, metadata=None, tstart=0, tstop=0):
+    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
-        :param fnames_alt: alternative data to show (e.g. synthetic/processed)
         :type fnames: list
         """
         self.wfdata = Stream()
         self.wforiginal = None
-        self.wf_alt = Stream()
+        self.wfsyn = Stream()
         if tstart == tstop:
             tstart = tstop = None
         self.tstart = tstart
         self.tstop = tstop
 
-        # remove directories
-        fnames = [fname for fname in fnames if not os.path.isdir(fname)]
-        fnames_alt = [fname for fname in fnames_alt if not os.path.isdir(fname)]
-
         # if obspy_dmt:
         #     wfdir = 'raw'
         #     self.processed = False
@@ -487,8 +482,8 @@ class Data(object):
         #     wffnames = fnames
         if fnames is not None:
             self.appendWFData(fnames)
-            if fnames_alt is not None:
-                self.appendWFData(fnames_alt, alternative=True)
+            if fnames_syn is not None:
+                self.appendWFData(fnames_syn, synthetic=True)
         else:
             return False
 
@@ -508,7 +503,7 @@ class Data(object):
         self.dirty = False
         return True
 
-    def appendWFData(self, fnames, alternative=False):
+    def appendWFData(self, fnames, synthetic=False):
         """
         Read waveform data from fnames and append it to current wf data
         :param fnames: waveform data to append
@@ -521,20 +516,20 @@ class Data(object):
         if self.dirty:
             self.resetWFData()
 
-        orig_or_alternative_data = {True: self.wf_alt,
-                                    False: self.wfdata}
+        real_or_syn_data = {True: self.wfsyn,
+                            False: self.wfdata}
 
         warnmsg = ''
         for fname in set(fnames):
             try:
-                orig_or_alternative_data[alternative] += read(fname, starttime=self.tstart, endtime=self.tstop)
+                real_or_syn_data[synthetic] += read(fname, starttime=self.tstart, endtime=self.tstop)
             except TypeError:
                 try:
-                    orig_or_alternative_data[alternative] += read(fname, format='GSE2', starttime=self.tstart, endtime=self.tstop)
+                    real_or_syn_data[synthetic] += read(fname, format='GSE2', starttime=self.tstart, endtime=self.tstop)
                 except Exception as e:
                     try:
-                        orig_or_alternative_data[alternative] += read(fname, format='SEGY', starttime=self.tstart,
-                                                                      endtime=self.tstop)
+                        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:
@@ -549,8 +544,8 @@ class Data(object):
     def getOriginalWFData(self):
         return self.wforiginal
 
-    def getAltWFdata(self):
-        return self.wf_alt
+    def getSynWFData(self):
+        return self.wfsyn
 
     def resetWFData(self):
         """

pylot/core/io/location.py

@@ -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:

pylot/core/io/phases.py

@@ -16,7 +16,7 @@ from pylot.core.io.inputs import PylotParameter
 from pylot.core.io.location import create_event, \
     create_magnitude
 from pylot.core.pick.utils import select_for_phase, get_quality_class
-from pylot.core.util.utils import getOwner, full_range, four_digits, transformFilterString4Export, \
+from pylot.core.util.utils import get_owner, full_range, four_digits, transformFilterString4Export, \
     backtransformFilterString, loopIdentifyPhase, identifyPhase
 
 
@@ -58,7 +58,7 @@ def readPILOTEvent(phasfn=None, locfn=None, authority_id='RUB', **kwargs):
     if phasfn is not None and os.path.isfile(phasfn):
         phases = sio.loadmat(phasfn)
         phasctime = UTCDateTime(os.path.getmtime(phasfn))
-        phasauthor = getOwner(phasfn)
+        phasauthor = get_owner(phasfn)
     else:
         phases = None
         phasctime = None
@@ -66,7 +66,7 @@ def readPILOTEvent(phasfn=None, locfn=None, authority_id='RUB', **kwargs):
     if locfn is not None and os.path.isfile(locfn):
         loc = sio.loadmat(locfn)
         locctime = UTCDateTime(os.path.getmtime(locfn))
-        locauthor = getOwner(locfn)
+        locauthor = get_owner(locfn)
     else:
         loc = None
         locctime = None
@@ -280,7 +280,6 @@ def picksdict_from_picks(evt):
             infile = os.path.join(os.path.expanduser('~'), '.pylot', 'pylot.in')
             print('Using default input file {}'.format(infile))
             parameter = PylotParameter(infile)
-            pick.phase_hint = identifyPhase(pick.phase_hint)
             if pick.phase_hint == 'P':
                 errors = parameter['timeerrorsP']
             elif pick.phase_hint == 'S':

pylot/core/loc/nll.py

@@ -82,8 +82,8 @@ def locate(fnin, parameter=None):
     :param fnin: external program name
     :return: None
     """
-    exe_path = os.path.join(parameter['nllocbin'], 'NLLoc')
-    if not os.path.isfile(exe_path):
+    exe_path = parameter['nllocbin'] + '/bin/NLLoc'    
+    if exe_path is None:
         raise NLLocError('NonLinLoc executable not found; check your '
                          'environment variables')
 

pylot/core/pick/autopick.py

@@ -22,7 +22,7 @@ from pylot.core.pick.picker import AICPicker, PragPicker
 from pylot.core.pick.utils import checksignallength, checkZ4S, earllatepicker, \
     getSNR, fmpicker, checkPonsets, wadaticheck, get_quality_class
 from pylot.core.util.utils import getPatternLine, gen_Pool, \
-    get_bool, identifyPhaseID, get_None, correct_iplot
+    get_bool, identifyPhaseID, get_none, correct_iplot
 
 
 def autopickevent(data, param, iplot=0, fig_dict=None, fig_dict_wadatijack=None, ncores=0, metadata=None, origin=None):
@@ -272,7 +272,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
 
@@ -936,7 +936,7 @@ class AutopickStation(object):
             "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.copy(), z_copy, self.pickparams["fmpickwin"], self.p_results.mpp,
+            self.p_results.fm = fmpicker(self.zstream, 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)

pylot/core/pick/picker.py

@@ -336,7 +336,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 Exception as e:
+            except ValueError as e:
                 print("AICPicker: Problems with data fitting! {}".format(e))
 
         else:

pylot/core/pick/utils.py

@@ -15,7 +15,7 @@ import numpy as np
 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'):
@@ -62,7 +62,7 @@ def earllatepicker(X, nfac, TSNR, Pick1, iplot=0, verbosity=1, fig=None, linecol
     plt_flag = 0
     try:
         iplot = int(iplot)
-    except ValueError:
+    except:
         if get_bool(iplot):
             iplot = 2
         else:
@@ -136,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
@@ -275,7 +275,7 @@ def fmpicker(Xraw, Xfilt, pickwin, Pick, iplot=0, fig=None, linecolor='k'):
             try:
                 P1 = np.polyfit(xslope1, xraw[islope1], 1)
                 datafit1 = np.polyval(P1, xslope1)
-            except Exception as e:
+            except ValueError as e:
                 print("fmpicker: Problems with data fit! {}".format(e))
                 print("Skip first motion determination!")
                 return FM
@@ -321,7 +321,7 @@ def fmpicker(Xraw, Xfilt, pickwin, Pick, iplot=0, fig=None, linecolor='k'):
             try:
                 P2 = np.polyfit(xslope2, xfilt[islope2], 1)
                 datafit2 = np.polyval(P2, xslope2)
-            except Exception as e:
+            except ValueError as e:
                 emsg = 'fmpicker: polyfit failed: {}'.format(e)
                 print(emsg)
                 return FM
@@ -344,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
@@ -868,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
@@ -1211,14 +1211,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)
@@ -1508,7 +1508,7 @@ 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]:

pylot/core/util/array_map.py

@@ -75,6 +75,7 @@ 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()
@@ -463,19 +464,17 @@ class Array_map(QtWidgets.QWidget):
                                                                   transform=ccrs.PlateCarree(), label='deleted'))
 
     def openPickDlg(self, ind):
-        wfdata = self._parent.get_data().getWFData()
-        wfdata_comp = self._parent.get_data().getWFDataComp()
+        data = self._parent.get_data().getWFData()
         for index in ind:
             network, station = self._station_onpick_ids[index].split('.')[:2]
             pyl_mw = self._parent
             try:
-                wfdata = wfdata.select(station=station)
-                wfdata_comp = wfdata_comp.select(station=station)
-                if not wfdata:
+                data = data.select(station=station)
+                if not data:
                     self._warn('No data for station {}'.format(station))
                     return
                 pickDlg = PickDlg(self._parent, parameter=self.parameter,
-                                  data=wfdata.copy(), data_compare=wfdata_comp.copy(), network=network, station=station,
+                                  data=data, 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,

pylot/core/util/dataprocessing.py

@@ -271,7 +271,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)  # TODO: Commented out, failed with Parser, is this needed?
+                robj.get_coordinates(station_seed_id)
                 self.inventory_files[fname] = {'invtype': invtype,
                                                'data': robj}
                 if station_seed_id in self.seed_ids.keys():

pylot/core/util/utils.py

@@ -7,6 +7,7 @@ import platform
 import re
 import subprocess
 import warnings
+from typing import Literal, Tuple, Type
 
 import numpy as np
 from obspy import UTCDateTime, read
@@ -18,6 +19,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:
@@ -81,25 +86,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 +151,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 +287,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,15 +299,32 @@ 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
@@ -331,18 +334,38 @@ def get_bool(value):
     """
     Convert string representations of bools to their true boolean value
     :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
     """
-    if type(value) is bool:
+    if type(value) == bool:
         return value
     elif value in ['True', 'true']:
         return True
     elif value in ['False', 'false']:
         return False
+    elif value > 0. or value > 0:
+        return True
     else:
-        return bool(value)
+        return False
+
 
 def four_digits(year):
     """
@@ -353,8 +376,8 @@ def four_digits(year):
     :return: four digit year correspondent
     :rtype: int
 
-    >>> four_digits(20)
-    1920
+    >>> four_digits(75)
+    1975
     >>> four_digits(16)
     2016
     >>> four_digits(00)
@@ -436,36 +459,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
-    :return: login ID
+    returns the actual user's name
+    :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"]:
@@ -511,6 +551,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)
 
@@ -537,24 +582,36 @@ def isSorted(iterable):
     >>> isSorted([2,3,1,4])
     False
     """
-    assert isIterable(iterable), 'object is not iterable; object: {' \
-                                 '}'.format(iterable)
+    assert is_iterable(iterable), "object is not iterable; object: {}".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
@@ -563,13 +620,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:
@@ -577,32 +640,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
-    :type stime: `~obspy.core.utcdatetime.UTCDateTime`
+    :param offset: offset of the actual seismogram on plotting axis
+    :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
-    time_ax = np.linspace(stime, etime, nsamp)
+    etime = offset + nsamp / srate
+    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'
@@ -618,13 +702,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:
@@ -635,7 +719,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.
 
@@ -648,7 +732,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)}
@@ -704,17 +788,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)
-    :param modifier: which color should be modified, eg. 'r', 'g', 'b'
-    :type modifier: str
+    :type rgba: Rgba
+    :param modifier: which color should be modified; options: 'r', 'g', 'b'
+    :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,
@@ -748,18 +832,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 colors_mpl
+        return '({}, {}, {}, {})'.format(*transform_colors_mpl(colors))
 
 
 def transform_colors_mpl(colors):
@@ -769,27 +855,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
@@ -899,11 +974,11 @@ def check4doubled(data):
 
 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:
@@ -930,66 +1005,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
-        :type wfstream: `~obspy.core.stream.Stream`
+        :param wfs_in: stream containing seismic traces of a station
+        :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`
         """
 
-        # check if any traces in this station need to be rotated
-        trace_ids = [trace.id for trace in wfstream]
-        orientations = [trace_id[-1] for trace_id in trace_ids]
-        rotation_required = [orientation.isnumeric() for orientation in orientations]
-        if any(rotation_required):
-            t_start = full_range(wfstream)
-            try:
-                azimuts = []
-                dips = []
-                for tr_id in trace_ids:
-                    azimuts.append(metadata.get_coordinates(tr_id, t_start)['azimuth'])
-                    dips.append(metadata.get_coordinates(tr_id, t_start)['dip'])
-            except (KeyError, TypeError) as e:
-                print('Failed to rotate trace {}, no azimuth or dip available in metadata'.format(tr_id))
-                return wfstream
-            if len(wfstream) < 3:
-                print('Failed to rotate Stream {}, not enough components available.'.format(wfstream))
-                return wfstream
-            # to rotate all traces must have same length, so trim them
-            wfstream = trim_station_components(wfstream, trim_start=True, trim_end=True)
-            try:
-                z, n, e = rotate2zne(wfstream[0], azimuts[0], dips[0],
-                                     wfstream[1], azimuts[1], dips[1],
-                                     wfstream[2], azimuts[2], dips[2])
-                print('check4rotated: rotated 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)
-                wfstream[z_index].data = z
-                wfstream[z_index].stats.channel = wfstream[z_index].stats.channel[0:-1] + 'Z'
-                del trace_ids[z_index]
-                for trace_id in trace_ids:
-                    coordinates = metadata.get_coordinates(trace_id, t_start)
-                    dip, az = coordinates['dip'], coordinates['azimuth']
-                    trace = wfstream.select(id=trace_id)[0]
-                    if az > 315 or az <= 45 or az > 135 and az <= 225:
-                        trace.data = n
-                        trace.stats.channel = trace.stats.channel[0:-1] + 'N'
-                    elif az > 45 and az <= 135 or az > 225 and az <= 315:
-                        trace.data = e
-                        trace.stats.channel = trace.stats.channel[0:-1] + 'E'
-            except (ValueError) as e:
-                print(e)
-                return wfstream
+        if len(wfs_in) < 3:
+            print(f"Stream {wfs_in=}, has not enough components to rotate.")
+            return wfs_in
 
-        return wfstream
+        # check if any traces in this station need to be rotated
+        trace_ids = [trace.id for trace in wfs_in]
+        if not rotation_required(trace_ids):
+            print(f"Stream does not need any rotation: Traces are {trace_ids=}")
+            return wfs_in
+
+        # check metadata quality
+        t_start = full_range(wfs_in)
+        try:
+            azimuths = []
+            dips = []
+            for tr_id in trace_ids:
+                azimuths.append(metadata.get_coordinates(tr_id, t_start)['azimuth'])
+                dips.append(metadata.get_coordinates(tr_id, t_start)['dip'])
+        except (KeyError, TypeError) as err:
+            print(f"{type(err)=} occurred: {err=} Rotating not possible, not all azimuth and dip information "
+                  f"available in metadata. Stream remains unchanged.")
+            return wfs_in
+        except Exception as err:
+            print(f"Unexpected {err=}, {type(err)=}")
+            raise
+
+        # to rotate all traces must have same length, so trim them
+        wfs_out = trim_station_components(wfs_in, trim_start=True, trim_end=True)
+        try:
+            z, n, e = rotate2zne(wfs_out[0], azimuths[0], dips[0],
+                                 wfs_out[1], azimuths[1], dips[1],
+                                 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)
+            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 = wfs_out.select(id=trace_id)[0]
+                if az > 315 or az <= 45 or 135 < az <= 225:
+                    trace.data = n
+                    trace.stats.channel = trace.stats.channel[0:-1] + 'N'
+                elif 45 < az <= 135 or 225 < az <= 315:
+                    trace.data = e
+                    trace.stats.channel = trace.stats.channel[0:-1] + 'E'
+        except ValueError as err:
+            print(f"{err=} Rotation failed. Stream remains unchanged.")
+            return wfs_in
+
+        return wfs_out
 
     if metadata is None:
         if verbosity:
@@ -1003,38 +1099,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

pylot/core/util/widgets.py

@@ -49,11 +49,11 @@ from pylot.core.pick.utils import getSNR, earllatepicker, getnoisewin, \
 from pylot.core.pick.compare import Comparison
 from pylot.core.pick.autopick import fmpicker
 from pylot.core.util.defaults import OUTPUTFORMATS, FILTERDEFAULTS
-from pylot.core.util.utils import prepTimeAxis, full_range, demeanTrace, isSorted, findComboBoxIndex, clims, \
+from pylot.core.util.utils import prep_time_axis, full_range, demeanTrace, isSorted, findComboBoxIndex, clims, \
     pick_linestyle_plt, pick_color_plt, \
     check4rotated, check4doubled, merge_stream, identifyPhase, \
     loopIdentifyPhase, trim_station_components, transformFilteroptions2String, \
-    identifyPhaseID, get_bool, get_None, pick_color, getAutoFilteroptions, SetChannelComponents, \
+    identifyPhaseID, get_bool, get_none, pick_color, getAutoFilteroptions, SetChannelComponents, \
     station_id_remove_channel
 from autoPyLoT import autoPyLoT
 from pylot.core.util.thread import Thread
@@ -793,7 +793,7 @@ class WaveformWidgetPG(QtWidgets.QWidget):
 
     def connect_signals(self):
         self.qcombo_processed.activated.connect(self.parent().newWF)
-        self.comp_checkbox.clicked.connect(self.parent().newWF)
+        self.syn_checkbox.clicked.connect(self.parent().newWF)
 
     def init_labels(self):
         self.label_layout.addWidget(self.status_label)
@@ -804,13 +804,13 @@ class WaveformWidgetPG(QtWidgets.QWidget):
         # use widgets as placeholder, so that child widgets keep position when others are hidden
         mid_layout = QHBoxLayout()
         right_layout = QHBoxLayout()
-        mid_layout.addWidget(self.comp_checkbox)
+        mid_layout.addWidget(self.syn_checkbox)
         right_layout.addWidget(self.qcombo_processed)
         mid_widget.setLayout(mid_layout)
         right_widget.setLayout(right_layout)
         self.label_layout.addWidget(mid_widget)
         self.label_layout.addWidget(right_widget)
-        self.comp_checkbox.setLayoutDirection(Qt.RightToLeft)
+        self.syn_checkbox.setLayoutDirection(Qt.RightToLeft)
         self.label_layout.setStretch(0, 4)
         self.label_layout.setStretch(1, 0)
         self.label_layout.setStretch(2, 0)
@@ -825,7 +825,7 @@ class WaveformWidgetPG(QtWidgets.QWidget):
             label = QtWidgets.QLabel()
             self.perm_labels.append(label)
         self.qcombo_processed = QtWidgets.QComboBox()
-        self.comp_checkbox = QtWidgets.QCheckBox('Load comparison data')
+        self.syn_checkbox = QtWidgets.QCheckBox('synthetics')
         self.addQCboxItem('processed', 'green')
         self.addQCboxItem('raw', 'black')
         # self.perm_qcbox_right.setAlignment(2)
@@ -834,11 +834,9 @@ class WaveformWidgetPG(QtWidgets.QWidget):
     def getPlotDict(self):
         return self.plotdict
 
-    def activateObspyDMToptions(self, activate: bool) -> None:
-        self.qcombo_processed.setEnabled(activate)
-
-    def activateCompareOptions(self, activate: bool) -> None:
-        self.comp_checkbox.setEnabled(activate)
+    def activateObspyDMToptions(self, activate):
+        self.syn_checkbox.setVisible(activate)
+        self.qcombo_processed.setVisible(activate)
 
     def setPermText(self, number, text=None, color='black'):
         if not 0 <= number < len(self.perm_labels):
@@ -862,8 +860,10 @@ class WaveformWidgetPG(QtWidgets.QWidget):
     def clearPlotDict(self):
         self.plotdict = dict()
 
-    def plotWFData(self, wfdata, wfsyn=None, title=None, scaleddata=False, mapping=True,
-                   component='*', nth_sample=1, verbosity=0, method='normal', gain=1., shift_syn=0.2):
+    def plotWFData(self, wfdata, wfsyn=None, title=None, zoomx=None, zoomy=None,
+                   noiselevel=None, scaleddata=False, mapping=True,
+                   component='*', nth_sample=1, iniPick=None, verbosity=0,
+                   method='normal', gain=1.):
         if not wfdata:
             print('Nothing to plot.')
             return
@@ -923,10 +923,10 @@ class WaveformWidgetPG(QtWidgets.QWidget):
                 msg = 'plotting %s channel of station %s' % (channel, station)
                 print(msg)
             stime = trace.stats.starttime - self.wfstart
-            time_ax = prepTimeAxis(stime, trace)
+            time_ax = prep_time_axis(stime, trace)
             if st_syn:
                 stime_syn = trace_syn.stats.starttime - self.wfstart
-                time_ax_syn = prepTimeAxis(stime_syn, trace_syn)
+                time_ax_syn = prep_time_axis(stime_syn, trace_syn)
 
             if method == 'fast':
                 trace.data, time_ax = self.minMax(trace, time_ax)
@@ -946,7 +946,7 @@ class WaveformWidgetPG(QtWidgets.QWidget):
                     [time for index, time in enumerate(time_ax_syn) if not index % nth_sample] if st_syn else [])
                 trace.data = np.array(
                     [datum * gain + n for index, datum in enumerate(trace.data) if not index % nth_sample])
-                trace_syn.data = np.array([datum + n + shift_syn for index, datum in enumerate(trace_syn.data)
+                trace_syn.data = np.array([datum + n for index, datum in enumerate(trace_syn.data)
                                            if not index % nth_sample] if st_syn else [])
                 plots.append((times, trace.data,
                               times_syn, trace_syn.data))
@@ -1135,12 +1135,12 @@ class PylotCanvas(FigureCanvas):
         ax.set_xlim(self.cur_xlim)
         ax.set_ylim(self.cur_ylim)
         self.refreshPickDlgText()
-        ax.figure.canvas.draw_idle()
+        ax.figure.canvas.draw()
 
     def panRelease(self, gui_event):
         self.press = None
         self.press_rel = None
-        self.figure.canvas.draw_idle()
+        self.figure.canvas.draw()
 
     def panZoom(self, gui_event, threshold=2., factor=1.1):
         if not gui_event.x and not gui_event.y:
@@ -1358,15 +1358,11 @@ class PylotCanvas(FigureCanvas):
             plot_positions[channel] = plot_pos
         return plot_positions
 
-    def plotWFData(self, wfdata, wfdata_compare=None, title=None, zoomx=None, zoomy=None,
+    def plotWFData(self, wfdata, title=None, zoomx=None, zoomy=None,
                    noiselevel=None, scaleddata=False, mapping=True,
                    component='*', nth_sample=1, iniPick=None, verbosity=0,
                    plot_additional=False, additional_channel=None, scaleToChannel=None,
                    snr=None):
-        def get_wf_dict(data: Stream = Stream(), linecolor = 'k', offset: float = 0., **plot_kwargs):
-            return dict(data=data, linecolor=linecolor, offset=offset, plot_kwargs=plot_kwargs)
-
-
         ax = self.axes[0]
         ax.cla()
 
@@ -1377,33 +1373,21 @@ class PylotCanvas(FigureCanvas):
         settings = QSettings()
         compclass = SetChannelComponents.from_qsettings(settings)
 
-        linecolor = (0., 0., 0., 1.) if not self.style else self.style['linecolor']['rgba_mpl']
-
-        plot_streams = dict(wfdata=get_wf_dict(linecolor=linecolor, linewidth=0.7),
-                            wfdata_comp=get_wf_dict(offset=0.1, linecolor='b', alpha=0.7, linewidth=0.5))
-
         if not component == '*':
             alter_comp = compclass.getCompPosition(component)
             # alter_comp = str(alter_comp[0])
 
-            plot_streams['wfdata']['data'] = wfdata.select(component=component)
-            plot_streams['wfdata']['data'] += wfdata.select(component=alter_comp)
-            if wfdata_compare:
-                plot_streams['wfdata_comp']['data'] = wfdata_compare.select(component=component)
-                plot_streams['wfdata_comp']['data'] += wfdata_compare.select(component=alter_comp)
+            st_select = wfdata.select(component=component)
+            st_select += wfdata.select(component=alter_comp)
         else:
-            plot_streams['wfdata']['data'] = wfdata
-            if wfdata_compare:
-                plot_streams['wfdata_comp']['data'] = wfdata_compare
-            
-        st_main = plot_streams['wfdata']['data']
+            st_select = wfdata
 
         if mapping:
-            plot_positions = self.calcPlotPositions(st_main, compclass)
+            plot_positions = self.calcPlotPositions(st_select, compclass)
 
         # list containing tuples of network, station, channel and plot position (for sorting)
         nslc = []
-        for plot_pos, trace in enumerate(st_main):
+        for plot_pos, trace in enumerate(st_select):
             if not trace.stats.channel[-1] in ['Z', 'N', 'E', '1', '2', '3']:
                 print('Warning: Unrecognized channel {}'.format(trace.stats.channel))
                 continue
@@ -1411,48 +1395,44 @@ class PylotCanvas(FigureCanvas):
         nslc.sort()
         nslc.reverse()
 
+        linecolor = (0., 0., 0., 1.) if not self.style else self.style['linecolor']['rgba_mpl']
+
         for n, seed_id in enumerate(nslc):
             network, station, location, channel = seed_id.split('.')
-            for wf_name, wf_dict in plot_streams.items():
-                st_select = wf_dict.get('data')
-                if not st_select:
-                    continue
-                st = st_select.select(id=seed_id)
-                trace = st[0].copy()
-                if mapping:
-                    n = plot_positions[trace.stats.channel]
-                if n > nmax:
-                    nmax = n
-                if verbosity:
-                    msg = 'plotting %s channel of station %s' % (channel, station)
-                    print(msg)
-                stime = trace.stats.starttime - wfstart
-                time_ax = prepTimeAxis(stime, trace)
-                if time_ax is not None:
-                    if scaleToChannel:
-                        st_scale = wfdata.select(channel=scaleToChannel)
-                        if st_scale:
-                            tr = st_scale[0]
-                            trace.detrend('constant')
-                            trace.normalize(np.max(np.abs(tr.data)) * 2)
-                            scaleddata = True
-                    if not scaleddata:
+            st = st_select.select(id=seed_id)
+            trace = st[0].copy()
+            if mapping:
+                n = plot_positions[trace.stats.channel]
+            if n > nmax:
+                nmax = n
+            if verbosity:
+                msg = 'plotting %s channel of station %s' % (channel, station)
+                print(msg)
+            stime = trace.stats.starttime - wfstart
+            time_ax = prep_time_axis(stime, trace)
+            if time_ax is not None:
+                if scaleToChannel:
+                    st_scale = wfdata.select(channel=scaleToChannel)
+                    if st_scale:
+                        tr = st_scale[0]
                         trace.detrend('constant')
-                        trace.normalize(np.max(np.abs(trace.data)) * 2)
+                        trace.normalize(np.max(np.abs(tr.data)) * 2)
+                        scaleddata = True
+                if not scaleddata:
+                    trace.detrend('constant')
+                    trace.normalize(np.max(np.abs(trace.data)) * 2)
 
-                    offset = wf_dict.get('offset')
-
-                    times = [time for index, time in enumerate(time_ax) if not index % nth_sample]
-                    data = [datum + n + offset for index, datum in enumerate(trace.data) if not index % nth_sample]
-                    ax.axhline(n, color="0.5", lw=0.5)
-                    ax.plot(times, data, color=wf_dict.get('linecolor'), **wf_dict.get('plot_kwargs'))
-                    if noiselevel is not None:
-                        for level in [-noiselevel[channel], noiselevel[channel]]:
-                            ax.plot([time_ax[0], time_ax[-1]],
-                                    [n + level, n + level],
-                                    color=wf_dict.get('linecolor'),
-                                    linestyle='dashed')
-                    self.setPlotDict(n, seed_id)
+                times = [time for index, time in enumerate(time_ax) if not index % nth_sample]
+                data = [datum + n for index, datum in enumerate(trace.data) if not index % nth_sample]
+                ax.axhline(n, color="0.5", lw=0.5)
+                ax.plot(times, data, color=linecolor, linewidth=0.7)
+                if noiselevel is not None:
+                    for level in [-noiselevel[channel], noiselevel[channel]]:
+                        ax.plot([time_ax[0], time_ax[-1]],
+                                [n + level, n + level],
+                                color=linecolor,
+                                linestyle='dashed')
+                self.setPlotDict(n, seed_id)
         if plot_additional and additional_channel:
             compare_stream = wfdata.select(channel=additional_channel)
             if compare_stream:
@@ -1467,7 +1447,7 @@ class PylotCanvas(FigureCanvas):
                 if not scaleddata:
                     trace.detrend('constant')
                     trace.normalize(np.max(np.abs(trace.data)) * 2)
-                time_ax = prepTimeAxis(stime, trace)
+                time_ax = prep_time_axis(stime, trace)
                 times = [time for index, time in enumerate(time_ax) if not index % nth_sample]
                 p_data = compare_stream[0].data
                 # #normalize
@@ -1679,8 +1659,8 @@ class PhaseDefaults(QtWidgets.QDialog):
 class PickDlg(QDialog):
     update_picks = QtCore.Signal(dict)
 
-    def __init__(self, parent=None, data=None, data_compare=None, station=None, network=None, location=None, picks=None,
-                 autopicks=None, rotate=False, parameter=None, embedded=False, metadata=None, show_comp_data=False,
+    def __init__(self, parent=None, data=None, station=None, network=None, location=None, picks=None,
+                 autopicks=None, rotate=False, parameter=None, embedded=False, metadata=None,
                  event=None, filteroptions=None, model=None, wftype=None):
         super(PickDlg, self).__init__(parent, Qt.Window)
         self.orig_parent = parent
@@ -1689,7 +1669,6 @@ class PickDlg(QDialog):
         # initialize attributes
         self.parameter = parameter
         self._embedded = embedded
-        self.showCompData = show_comp_data
         self.station = station
         self.network = network
         self.location = location
@@ -1728,32 +1707,11 @@ class PickDlg(QDialog):
         else:
             self.filteroptions = FILTERDEFAULTS
         self.pick_block = False
-
-        # set attribute holding data
-        if data is None or not data:
-            try:
-                data = parent.get_data().getWFData().copy()
-                self.data = data.select(station=station)
-            except AttributeError as e:
-                errmsg = 'You either have to put in a data or an appropriate ' \
-                         'parent (PyLoT MainWindow) object: {0}'.format(e)
-                raise Exception(errmsg)
-        else:
-            self.data = data
-        self.data_compare = data_compare
-
         self.nextStation = QtWidgets.QCheckBox('Continue with next station ')
 
         # comparison channel
-        self.referenceChannel = QtWidgets.QComboBox()
-        self.referenceChannel.activated.connect(self.resetPlot)
-
-        # comparison channel
-        self.compareCB = QtWidgets.QCheckBox()
-        self.compareCB.setChecked(self.showCompData)
-        self.compareCB.clicked.connect(self.switchCompData)
-        self.compareCB.clicked.connect(self.resetPlot)
-        self.compareCB.setVisible(bool(self.data_compare))
+        self.compareChannel = QtWidgets.QComboBox()
+        self.compareChannel.activated.connect(self.resetPlot)
 
         # scale channel
         self.scaleChannel = QtWidgets.QComboBox()
@@ -1766,6 +1724,18 @@ class PickDlg(QDialog):
         self.cur_xlim = None
         self.cur_ylim = None
 
+        # set attribute holding data
+        if data is None or not data:
+            try:
+                data = parent.get_data().getWFData().copy()
+                self.data = data.select(station=station)
+            except AttributeError as e:
+                errmsg = 'You either have to put in a data or an appropriate ' \
+                         'parent (PyLoT MainWindow) object: {0}'.format(e)
+                raise Exception(errmsg)
+        else:
+            self.data = data
+
         self.stime, self.etime = full_range(self.getWFData())
 
         # initialize plotting widget
@@ -1777,12 +1747,12 @@ class PickDlg(QDialog):
         self.setupUi()
 
         # fill compare and scale channels
-        self.referenceChannel.addItem('-', None)
+        self.compareChannel.addItem('-', None)
         self.scaleChannel.addItem('individual', None)
 
         for trace in self.getWFData():
             channel = trace.stats.channel
-            self.referenceChannel.addItem(channel, trace)
+            self.compareChannel.addItem(channel, trace)
             if not channel[-1] in ['Z', 'N', 'E', '1', '2', '3']:
                 print('Skipping unknown channel for scaling: {}'.format(channel))
                 continue
@@ -1799,7 +1769,7 @@ class PickDlg(QDialog):
         if self.wftype is not None:
             title += ' | ({})'.format(self.wftype)
 
-        self.multicompfig.plotWFData(wfdata=self.getWFData(), wfdata_compare=self.getWFDataComp(),
+        self.multicompfig.plotWFData(wfdata=self.getWFData(),
                                      title=title)
 
         self.multicompfig.setZoomBorders2content()
@@ -1816,7 +1786,7 @@ class PickDlg(QDialog):
 
         # init expected picks using obspy Taup
         try:
-            if self.metadata and model != "None":
+            if self.metadata and model is not None:
                 self.model = TauPyModel(model)
                 self.get_arrivals()
                 self.drawArrivals()
@@ -1975,11 +1945,8 @@ class PickDlg(QDialog):
         _dialtoolbar.addWidget(est_label)
         _dialtoolbar.addWidget(self.plot_arrivals_button)
         _dialtoolbar.addSeparator()
-        _dialtoolbar.addWidget(QtWidgets.QLabel('Plot reference channel: '))
-        _dialtoolbar.addWidget(self.referenceChannel)
-        _dialtoolbar.addSeparator()
-        _dialtoolbar.addWidget(QtWidgets.QLabel('Compare: '))
-        _dialtoolbar.addWidget(self.compareCB)
+        _dialtoolbar.addWidget(QtWidgets.QLabel('Compare to channel: '))
+        _dialtoolbar.addWidget(self.compareChannel)
         _dialtoolbar.addSeparator()
         _dialtoolbar.addWidget(QtWidgets.QLabel('Scaling: '))
         _dialtoolbar.addWidget(self.scaleChannel)
@@ -2314,7 +2281,7 @@ class PickDlg(QDialog):
     def activatePicking(self):
         self.leave_rename_phase()
         self.renamePhaseAction.setEnabled(False)
-        self.referenceChannel.setEnabled(False)
+        self.compareChannel.setEnabled(False)
         self.scaleChannel.setEnabled(False)
         phase = self.currentPhase
         phaseID = self.getPhaseID(phase)
@@ -2346,7 +2313,7 @@ class PickDlg(QDialog):
         self.disconnectPressEvent()
         self.multicompfig.connectEvents()
         self.renamePhaseAction.setEnabled(True)
-        self.referenceChannel.setEnabled(True)
+        self.compareChannel.setEnabled(True)
         self.scaleChannel.setEnabled(True)
         self.connect_pick_delete()
         self.draw()
@@ -2419,12 +2386,6 @@ class PickDlg(QDialog):
     def getWFData(self):
         return self.data
 
-    def getWFDataComp(self):
-        if self.showCompData:
-            return self.data_compare
-        else:
-            return Stream()
-
     def selectWFData(self, channel):
         component = channel[-1].upper()
         wfdata = Stream()
@@ -2546,33 +2507,24 @@ class PickDlg(QDialog):
 
         stime = self.getStartTime()
 
-        # copy wfdata for plotting
-        wfdata = self.getWFData().copy()
-        wfdata_comp = self.getWFDataComp().copy()
-        wfdata = self.getPickPhases(wfdata, phase)
-        wfdata_comp = self.getPickPhases(wfdata_comp, phase)
-        for wfd in [wfdata, wfdata_comp]:
-            if wfd:
-                wfd.normalize()
-
-        if not wfdata:
+        # copy data for plotting
+        data = self.getWFData().copy()
+        data = self.getPickPhases(data, phase)
+        data.normalize()
+        if not data:
             QtWidgets.QMessageBox.warning(self, 'No channel to plot',
-                                          'No channel to plot for phase: {}. '
-                                          'Make sure to select the correct channels for P and S '
-                                          'in the menu in the top panel.'.format(phase))
+                                          'No channel to plot for phase: {}.'.format(phase))
             self.leave_picking_mode()
             return
 
-        # filter wfdata and trace on which is picked prior to determination of SNR
+        # filter data and trace on which is picked prior to determination of SNR
         filterphase = self.currentFilterPhase()
         if filterphase:
             filteroptions = self.getFilterOptions(filterphase).parseFilterOptions()
             try:
-                for wfd in [wfdata, wfdata_comp]:
-                    if wfd:
-                        wfd.detrend('linear')
-                        wfd.filter(**filteroptions)
-                # wfdata.filter(**filteroptions)# MP MP removed filtering of original wfdata
+                data.detrend('linear')
+                data.filter(**filteroptions)
+                # wfdata.filter(**filteroptions)# MP MP removed filtering of original data
             except ValueError as e:
                 self.qmb = QtWidgets.QMessageBox(QtWidgets.QMessageBox.Icon.Information,
                                                  'Denied',
@@ -2582,8 +2534,8 @@ class PickDlg(QDialog):
         snr = []
         noiselevels = {}
         # determine SNR and noiselevel
-        for trace in wfdata.traces:
-            st = wfdata.select(channel=trace.stats.channel)
+        for trace in data.traces:
+            st = data.select(channel=trace.stats.channel)
             stime_diff = trace.stats.starttime - stime
             result = getSNR(st, (noise_win, gap_win, signal_win), ini_pick - stime_diff)
             snr.append(result[0])
@@ -2594,25 +2546,23 @@ class PickDlg(QDialog):
                 noiselevel = nfac
             noiselevels[trace.stats.channel] = noiselevel
 
-        # prepare plotting of wfdata
-        for wfd in [wfdata, wfdata_comp]:
-            if wfd:
-                for trace in wfd:
-                    t = prepTimeAxis(trace.stats.starttime - stime, trace)
-                    inoise = getnoisewin(t, ini_pick, noise_win, gap_win)
-                    trace = demeanTrace(trace, inoise)
-                    # upscale trace wfdata in a way that each trace is vertically zoomed to noiselevel*factor
-                    channel = trace.stats.channel
-                    noiselevel = noiselevels[channel]
-                    noiseScaleFactor = self.calcNoiseScaleFactor(noiselevel, zoomfactor=5.)
-                    trace.data *= noiseScaleFactor
-                    noiselevels[channel] *= noiseScaleFactor
+        # prepare plotting of data
+        for trace in data:
+            t = prep_time_axis(trace.stats.starttime - stime, trace)
+            inoise = getnoisewin(t, ini_pick, noise_win, gap_win)
+            trace = demeanTrace(trace, inoise)
+            # upscale trace data in a way that each trace is vertically zoomed to noiselevel*factor
+            channel = trace.stats.channel
+            noiselevel = noiselevels[channel]
+            noiseScaleFactor = self.calcNoiseScaleFactor(noiselevel, zoomfactor=5.)
+            trace.data *= noiseScaleFactor
+            noiselevels[channel] *= noiseScaleFactor
 
         mean_snr = np.mean(snr)
         x_res = getResolutionWindow(mean_snr, parameter.get('extent'))
 
         xlims = [ini_pick - x_res, ini_pick + x_res]
-        ylims = list(np.array([-.5, .5]) + [0, len(wfdata) - 1])
+        ylims = list(np.array([-.5, .5]) + [0, len(data) - 1])
 
         title = self.getStation() + ' picking mode'
         title += ' | SNR: {}'.format(mean_snr)
@@ -2620,10 +2570,9 @@ class PickDlg(QDialog):
             filtops_str = transformFilteroptions2String(filteroptions)
             title += ' | Filteroptions: {}'.format(filtops_str)
 
-        plot_additional = bool(self.referenceChannel.currentText())
-        additional_channel = self.referenceChannel.currentText()
-        self.multicompfig.plotWFData(wfdata=wfdata,
-                                     wfdata_compare=wfdata_comp,
+        plot_additional = bool(self.compareChannel.currentText())
+        additional_channel = self.compareChannel.currentText()
+        self.multicompfig.plotWFData(wfdata=data,
                                      title=title,
                                      zoomx=xlims,
                                      zoomy=ylims,
@@ -2704,7 +2653,7 @@ class PickDlg(QDialog):
             minFMSNR = parameter.get('minFMSNR')
             quality = get_quality_class(spe, parameter.get('timeerrorsP'))
             if quality <= minFMweight and snr >= minFMSNR:
-                FM = fmpicker(self.getWFData().select(channel=channel).copy(), wfdata.copy(), parameter.get('fmpickwin'),
+                FM = fmpicker(self.getWFData().select(channel=channel), wfdata, parameter.get('fmpickwin'),
                               pick - stime_diff)
 
         # save pick times for actual phase
@@ -3014,8 +2963,7 @@ class PickDlg(QDialog):
         self.cur_xlim = self.multicompfig.axes[0].get_xlim()
         self.cur_ylim = self.multicompfig.axes[0].get_ylim()
         # self.multicompfig.updateCurrentLimits()
-        wfdata = self.getWFData().copy()
-        wfdata_comp = self.getWFDataComp().copy()
+        data = self.getWFData().copy()
         title = self.getStation()
         if filter:
             filtoptions = None
@@ -3023,22 +2971,19 @@ class PickDlg(QDialog):
                 filtoptions = self.getFilterOptions(self.getPhaseID(phase), gui_filter=True).parseFilterOptions()
 
             if filtoptions is not None:
-                for wfd in [wfdata, wfdata_comp]:
-                    if wfd:
-                        wfd.detrend('linear')
-                        wfd.taper(0.02, type='cosine')
-                        wfd.filter(**filtoptions)
+                data.detrend('linear')
+                data.taper(0.02, type='cosine')
+                data.filter(**filtoptions)
                 filtops_str = transformFilteroptions2String(filtoptions)
                 title += ' | Filteroptions: {}'.format(filtops_str)
 
         if self.wftype is not None:
             title += ' | ({})'.format(self.wftype)
 
-        plot_additional = bool(self.referenceChannel.currentText())
-        additional_channel = self.referenceChannel.currentText()
+        plot_additional = bool(self.compareChannel.currentText())
+        additional_channel = self.compareChannel.currentText()
         scale_channel = self.scaleChannel.currentText()
-        self.multicompfig.plotWFData(wfdata=wfdata, wfdata_compare=wfdata_comp,
-                                     title=title,
+        self.multicompfig.plotWFData(wfdata=data, title=title,
                                      zoomx=self.getXLims(),
                                      zoomy=self.getYLims(),
                                      plot_additional=plot_additional,
@@ -3111,9 +3056,6 @@ class PickDlg(QDialog):
         self.resetZoom()
         self.refreshPlot()
 
-    def switchCompData(self):
-        self.showCompData = self.compareCB.isChecked()
-
     def refreshPlot(self):
         if self.autoFilterAction.isChecked():
             self.filterActionP.setChecked(False)
@@ -3669,14 +3611,14 @@ class TuneAutopicker(QWidget):
         self.listWidget.scrollToBottom()
 
     def get_current_event(self):
-        path = self.get_current_event_fp()
+        path = self.eventBox.currentText()
         return self.parent().project.getEventFromPath(path)
 
     def get_current_event_name(self):
-        return self.eventBox.currentText().split('/')[-1].rstrip('*')
+        return self.eventBox.currentText().split('/')[-1].split('*')[0]
 
     def get_current_event_fp(self):
-        return self.eventBox.currentText().rstrip('*')
+        return self.eventBox.currentText().split('*')[0]
 
     def get_current_event_picks(self, station):
         event = self.get_current_event()
@@ -3724,13 +3666,11 @@ class TuneAutopicker(QWidget):
             location = None
 
         wfdata = self.data.getWFData()
-        wfdata_comp = self.data.getWFDataComp()
         metadata = self.parent().metadata
         event = self.get_current_event()
         filteroptions = self.parent().filteroptions
         wftype = self.wftype if self.obspy_dmt else ''
         self.pickDlg = PickDlg(self.parent(), data=wfdata.select(station=station).copy(),
-                               data_comp=wfdata_comp.select(station=station).copy(),
                                station=station, network=network,
                                location=location, parameter=self.parameter,
                                picks=self.get_current_event_picks(station),
@@ -3814,7 +3754,7 @@ class TuneAutopicker(QWidget):
             self.plot_manual_pick_to_ax(ax=ax, picks=picks, phase='S',
                                         starttime=starttime, quality=qualitySpick)
         for canvas in self.parent().canvas_dict.values():
-            canvas.draw_idle()
+            canvas.draw()
 
     def plot_manual_pick_to_ax(self, ax, picks, phase, starttime, quality):
         mpp = picks[phase]['mpp'] - starttime
@@ -4729,8 +4669,8 @@ class InputsTab(PropTab):
         self.tstopBox = QSpinBox()
         for spinbox in [self.tstartBox, self.tstopBox]:
             spinbox.setRange(-99999, 99999)
-        self.tstartBox.setValue(float(settings.value('tstart')) if get_None(settings.value('tstart')) else 0)
-        self.tstopBox.setValue(float(settings.value('tstop')) if get_None(settings.value('tstop')) else 1e6)
+        self.tstartBox.setValue(float(settings.value('tstart')) if get_none(settings.value('tstart')) else 0)
+        self.tstopBox.setValue(float(settings.value('tstop')) if get_none(settings.value('tstop')) else 1e6)
         self.cuttimesLayout.addWidget(self.tstartBox, 10)
         self.cuttimesLayout.addWidget(QLabel('[s] and'), 0)
         self.cuttimesLayout.addWidget(self.tstopBox, 10)