Merge branch 'feature/dae' into develop

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

PyLoT.py

@@ -25,6 +25,7 @@ https://www.iconfinder.com/iconsets/flavour
 
 import argparse
 import json
+import logging
 import os
 import platform
 import shutil
@@ -60,7 +61,7 @@ except ImportError:
     from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
 
-from pylot.core.analysis.magnitude import LocalMagnitude, MomentMagnitude, calcsourcespec
+from pylot.core.analysis.magnitude import LocalMagnitude, MomentMagnitude
 from pylot.core.io.data import Data
 from pylot.core.io.inputs import FilterOptions, PylotParameter
 from autoPyLoT import autoPyLoT
@@ -76,7 +77,7 @@ 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, get_pylot_eventfile_with_extension
+    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
@@ -84,7 +85,7 @@ from pylot.core.util.widgets import FilterOptionsDialog, NewEventDlg, \
     PylotCanvas, WaveformWidgetPG, PropertiesDlg, HelpForm, createAction, PickDlg, \
     ComparisonWidget, TuneAutopicker, PylotParaBox, AutoPickDlg, CanvasWidget, AutoPickWidget, \
     CompareEventsWidget, ProgressBarWidget, AddMetadataWidget, SingleTextLineDialog, LogWidget, PickQualitiesFromXml, \
-    SourceSpecWindow, ChooseWaveFormWindow, SpectrogramTab, SearchFileByExtensionDialog
+    SpectrogramTab, SearchFileByExtensionDialog
 from pylot.core.util.array_map import Array_map
 from pylot.core.util.structure import DATASTRUCTURE
 from pylot.core.util.thread import Thread, Worker
@@ -113,11 +114,7 @@ class MainWindow(QMainWindow):
     def __init__(self, parent=None, infile=None, reset_qsettings=False):
         super(MainWindow, self).__init__(parent)
 
-        # check for default pylot.in-file
+        if infile and os.path.isfile(infile) is False:
-        if not infile:
-            infile = os.path.join(os.path.expanduser('~'), '.pylot', 'pylot.in')
-            print('Using default input file {}'.format(infile))
-        if os.path.isfile(infile) is False:
             infile = QFileDialog().getOpenFileName(caption='Choose PyLoT-input file')[0]
 
             if not os.path.exists(infile):
@@ -181,6 +178,7 @@ class MainWindow(QMainWindow):
         self.autodata = Data(self)
 
         self.fnames = None
+        self.fnames_comp = None
         self._stime = None
 
         # track deleted picks for logging
@@ -253,7 +251,7 @@ class MainWindow(QMainWindow):
             self._inputs.reset_defaults()
             # check for default pylot.in-file
             infile = os.path.join(pylot_config_dir, '.pylot.in')
-            print('Using default input file {}'.format(infile))
+            logging.warning('Using default input file {}'.format(infile))
             self._inputs.export2File(infile)
         self.infile = infile
 
@@ -1010,13 +1008,13 @@ class MainWindow(QMainWindow):
                                           events=events)
         if not sld.exec_():
             return
-        fext = sld.comboBox.currentText()
+
-        # fext = '.xml'
+        filenames = sld.getChecked()
         for event in events:
-            filename = get_pylot_eventfile_with_extension(event, fext)
+            for filename in filenames:
-            if filename:
+                if os.path.isfile(filename) and event.pylot_id in filename:
-                self.load_data(filename, draw=False, event=event, overwrite=True)
+                    self.load_data(filename, draw=False, event=event, ask_user=True, merge_strategy=sld.merge_strategy)
-                refresh = True
+                    refresh = True
         if not refresh:
             return
         if self.get_current_event().pylot_picks:
@@ -1024,8 +1022,8 @@ class MainWindow(QMainWindow):
         self.fill_eventbox()
         self.setDirty(True)
 
-    def load_data(self, fname=None, loc=False, draw=True, event=None, overwrite=False):
+    def load_data(self, fname=None, loc=False, draw=True, event=None, ask_user=False, merge_strategy='Overwrite'):
-        if not overwrite:
+        if not ask_user:
             if not self.okToContinue():
                 return
         if fname is None:
@@ -1039,9 +1037,12 @@ class MainWindow(QMainWindow):
         data = Data(self, event)
         try:
             data_new = Data(self, evtdata=str(fname))
-            # MP MP commented because adding several picks might cause inconsistencies
+            if merge_strategy == 'Overwrite':
-            data = data_new
+                data = data_new
-            # data += data_new
+            elif merge_strategy == 'Merge':
+                data += data_new
+            else:
+                raise NotImplementedError(f'Unknown merge strategy: {merge_strategy}')
         except ValueError:
             qmb = QMessageBox(self, icon=QMessageBox.Question,
                               text='Warning: Missmatch in event identifiers {} and {}. Continue?'.format(
@@ -1129,16 +1130,19 @@ class MainWindow(QMainWindow):
             else:
                 return
 
-    def getWFFnames_from_eventbox(self, eventbox=None):
+    def getWFFnames_from_eventbox(self, eventbox: str = None, subpath: str = None) -> list:
         '''
         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)
-        basepath = eventpath.split(os.path.basename(eventpath))[0]
+        if subpath:
+            eventpath = os.path.join(eventpath, subpath)
+        if not os.path.isdir(eventpath):
+            return []
         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')
@@ -1960,13 +1964,20 @@ class MainWindow(QMainWindow):
 
     def prepareLoadWaveformData(self):
         self.fnames = self.getWFFnames_from_eventbox()
-        self.fnames_syn = []
+        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
+
         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):
         '''
@@ -1999,7 +2010,7 @@ class MainWindow(QMainWindow):
             tstop = None
 
         self.data.setWFData(self.fnames,
-                            self.fnames_syn,
+                            self.fnames_comp,
                             checkRotated=True,
                             metadata=self.metadata,
                             tstart=tstart,
@@ -2007,7 +2018,7 @@ class MainWindow(QMainWindow):
 
     def prepareObspyDMT_data(self, eventpath):
         qcbox_processed = self.dataPlot.qcombo_processed
-        qcheckb_syn = self.dataPlot.syn_checkbox
+        qcheckb_syn = self.dataPlot.comp_checkbox
         qcbox_processed.setEnabled(False)
         qcheckb_syn.setEnabled(False)
         for fpath in os.listdir(eventpath):
@@ -2015,8 +2026,8 @@ class MainWindow(QMainWindow):
             if 'syngine' in fpath:
                 eventpath_syn = os.path.join(eventpath, fpath)
                 qcheckb_syn.setEnabled(True)
-                if self.dataPlot.syn_checkbox.isChecked():
+                if self.dataPlot.comp_checkbox.isChecked():
-                    self.fnames_syn = [os.path.join(eventpath_syn, filename) for filename in os.listdir(eventpath_syn)]
+                    self.fnames_comp = [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 +2308,7 @@ class MainWindow(QMainWindow):
         comp = self.getComponent()
         title = 'section: {0} components'.format(zne_text[comp])
         wfst = self.get_data().getWFData()
-        wfsyn = self.get_data().getSynWFData()
+        wfsyn = self.get_data().getAltWFdata()
         if self.filterActionP.isChecked() and filter:
             self.filterWaveformData(plot=False, phase='P')
         elif self.filterActionS.isChecked() and filter:
@@ -2609,18 +2620,21 @@ class MainWindow(QMainWindow):
             print("Warning! No network, station, and location info available!")
             return
         self.update_status('picking on station {0}'.format(station))
-        data = self.get_data().getOriginalWFData().copy()
+        wfdata = self.get_data().getOriginalWFData().copy()
+        wfdata_comp = self.get_data().getAltWFdata().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=data.select(station=station),
+                          data=wfdata.select(station=station),
+                          data_compare=wfdata_comp.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)
+                          filteroptions=self.filteroptions, wftype=wftype,
+                          show_comp_data=self.dataPlot.comp_checkbox.isChecked())
         if self.filterActionP.isChecked():
             pickDlg.currentPhase = "P"
             pickDlg.filterWFData()
@@ -2999,10 +3013,16 @@ class MainWindow(QMainWindow):
             event = self.get_current_event()
         event.pylot_picks = {}
         event.pylot_autopicks = {}
-        picksdict = picksdict_from_picks(evt=self.get_data().get_evt_data())
+        picksdict = picksdict_from_picks(evt=self.get_data().get_evt_data(), parameter=self.getParameter())
         event.addPicks(picksdict['manual'])
         event.addAutopicks(picksdict['auto'])
 
+    def getParameter(self):
+        if hasattr(self.project, 'parameter') and isinstance(self.project.parameter, PylotParameter):
+            return self.project.parameter
+        else:
+            return self._inputs
+
     def drawPicks(self, station=None, picktype=None, stime=None):
         # if picktype not specified, draw both
         if not stime:

autoPyLoT.py

@@ -119,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:
-            parameter = PylotParameter(inputfile)
+            print('Using default input parameter')
-            # iplot = parameter['iplot']
+        parameter = PylotParameter(inputfile)
-        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)))

pylot/core/io/data.py

@@ -2,6 +2,7 @@
 # -*- coding: utf-8 -*-
 
 import copy
+import logging
 import os
 
 from PySide2.QtWidgets import QMessageBox
@@ -408,18 +409,16 @@ class Data(object):
                                      not implemented: {1}'''.format(evtformat, e))
             if fnext == '_focmec.in':
                 try:
-                    infile = os.path.join(os.path.expanduser('~'), '.pylot', 'pylot.in')
+                    parameter = PylotParameter()
-                    print('Using default input file {}'.format(infile))
+                    logging.warning('Using default input parameter')
-                    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')
+                    parameter = PylotParameter()
-                    print('Using default input file {}'.format(infile))
+                    logging.warning('Using default input parameter')
-                    parameter = PylotParameter(infile)
                     hypodd.export(picks_copy, fnout + fnext, parameter, eventinfo=self.get_evt_data())
                 except KeyError as e:
                     raise KeyError('''{0} export format
@@ -451,10 +450,11 @@ class Data(object):
         data.filter(**kwargs)
         self.dirty = True
 
-    def setWFData(self, fnames, fnames_syn=None, checkRotated=False, metadata=None, tstart=0, tstop=0):
+    def setWFData(self, fnames, fnames_alt=None, checkRotated=False, metadata=None, tstart=0, tstop=0):
         """
         Clear current waveform data and set given waveform data
         :param fnames: waveform data names to append
+        :param fnames_alt: alternative data to show (e.g. synthetic/processed)
         :type fnames: list
         """
         def check_fname_exists(filenames: list) -> list:
@@ -464,14 +464,16 @@ class Data(object):
 
         self.wfdata = Stream()
         self.wforiginal = None
-        self.wfsyn = Stream()
+        self.wf_alt = Stream()
         if tstart == tstop:
             tstart = tstop = None
         self.tstart = tstart
         self.tstop = tstop
 
+        # remove directories
         fnames = check_fname_exists(fnames)
-        fnames_syn = check_fname_exists(fnames_syn)
+        fnames_alt = check_fname_exists(fnames_alt)
+
         # if obspy_dmt:
         #     wfdir = 'raw'
         #     self.processed = False
@@ -489,8 +491,8 @@ class Data(object):
         #     wffnames = fnames
         if fnames is not None:
             self.appendWFData(fnames)
-            if fnames_syn is not None:
+            if fnames_alt is not None:
-                self.appendWFData(fnames_syn, synthetic=True)
+                self.appendWFData(fnames_alt, alternative=True)
         else:
             return False
 
@@ -512,7 +514,7 @@ class Data(object):
         self.dirty = False
         return True
 
-    def appendWFData(self, fnames, synthetic=False):
+    def appendWFData(self, fnames, alternative=False):
         """
         Read waveform data from fnames and append it to current wf data
         :param fnames: waveform data to append
@@ -525,20 +527,20 @@ class Data(object):
         if self.dirty:
             self.resetWFData()
 
-        real_or_syn_data = {True: self.wfsyn,
+        orig_or_alternative_data = {True: self.wf_alt,
-                            False: self.wfdata}
+                                    False: self.wfdata}
 
         warnmsg = ''
         for fname in set(fnames):
             try:
-                real_or_syn_data[synthetic] += read(fname, starttime=self.tstart, endtime=self.tstop)
+                orig_or_alternative_data[alternative] += 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)
+                    orig_or_alternative_data[alternative] += 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,
+                        orig_or_alternative_data[alternative] += read(fname, format='SEGY', starttime=self.tstart,
-                                                            endtime=self.tstop)
+                                                                      endtime=self.tstop)
                     except Exception as e:
                         warnmsg += '{0}\n{1}\n'.format(fname, e)
             except SacIOError as se:
@@ -553,8 +555,8 @@ class Data(object):
     def getOriginalWFData(self):
         return self.wforiginal
 
-    def getSynWFData(self):
+    def getAltWFdata(self):
-        return self.wfsyn
+        return self.wf_alt
 
     def resetWFData(self):
         """

pylot/core/io/phases.py

@@ -1,6 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 import glob
+import logging
 import os
 import warnings
 
@@ -217,7 +218,7 @@ def picksdict_from_obs(fn):
     return picks
 
 
-def picksdict_from_picks(evt):
+def picksdict_from_picks(evt, parameter=None):
     """
     Takes an Event object and return the pick dictionary commonly used within
     PyLoT
@@ -230,6 +231,7 @@ def picksdict_from_picks(evt):
         'auto': {}
     }
     for pick in evt.picks:
+        errors = None
         phase = {}
         station = pick.waveform_id.station_code
         if pick.waveform_id.channel_code is None:
@@ -273,32 +275,28 @@ def picksdict_from_picks(evt):
         phase['epp'] = epp
         phase['lpp'] = lpp
         phase['spe'] = spe
-        try:
+        weight = phase.get('weight')
-            phase['weight'] = weight
+        if not weight:
-        except:
+            if not parameter:
-            # get onset weight from uncertainty
+                logging.warning('Using ')
-            infile = os.path.join(os.path.expanduser('~'), '.pylot', 'pylot.in')
+                logging.warning('Using default input parameter')
-            print('Using default input file {}'.format(infile))
+                parameter = PylotParameter()
-            parameter = PylotParameter(infile)
             pick.phase_hint = identifyPhase(pick.phase_hint)
             if pick.phase_hint == 'P':
                 errors = parameter['timeerrorsP']
             elif pick.phase_hint == 'S':
                 errors = parameter['timeerrorsS']
-            weight = get_quality_class(spe, errors)
+            if errors:
-            phase['weight'] = weight
+                weight = get_quality_class(spe, errors)
+                phase['weight'] = weight
         phase['channel'] = channel
         phase['network'] = network
         phase['picker'] = pick_method
-        try:
+        if pick.polarity == 'positive':
-            if pick.polarity == 'positive':
+            phase['fm'] = 'U'
-                phase['fm'] = 'U'
+        elif pick.polarity == 'negative':
-            elif pick.polarity == 'negative':
+            phase['fm'] = 'D'
-                phase['fm'] = 'D'
+        else:
-            else:
-                phase['fm'] = 'N'
-        except:
-            print("No FM info available!")
             phase['fm'] = 'N'
         phase['filter_id'] = filter_id if filter_id is not None else ''
 

pylot/core/util/array_map.py

@@ -124,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)
@@ -474,17 +474,19 @@ 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().getWFData()
+        wfdata_comp = self._parent.get_data().getWFDataComp()
         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,

pylot/core/util/utils.py

@@ -334,7 +334,7 @@ def get_none(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, int, float
     :return: true boolean value
@@ -356,6 +356,8 @@ def get_bool(value):
     False
     >>> get_bool(-0.3)
     False
+    >>> get_bool(None)
+    None
     """
     if type(value) is bool:
         return value
@@ -363,10 +365,13 @@ def get_bool(value):
         return True
     elif value in ['False', 'false']:
         return False
-    elif value > 0. or value > 0:
+    elif isinstance(value, float) or isinstance(value, int):
-        return True
+        if value > 0. or value > 0:
+            return True
+        else:
+            return False
     else:
-        return False
+        return value
 
 
 def four_digits(year):
@@ -1067,7 +1072,7 @@ def check4rotated(data, metadata=None, verbosity=1):
         # 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=}")
+            logging.debug(f"Stream does not need any rotation: Traces are {trace_ids=}")
             return wfs_in
 
         # check metadata quality
@@ -1079,7 +1084,7 @@ def check4rotated(data, metadata=None, verbosity=1):
                 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 "
+            logging.error(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:

pylot/core/util/widgets.py

@@ -795,7 +795,7 @@ class WaveformWidgetPG(QtWidgets.QWidget):
 
     def connect_signals(self):
         self.qcombo_processed.activated.connect(self.parent().newWF)
-        self.syn_checkbox.clicked.connect(self.parent().newWF)
+        self.comp_checkbox.clicked.connect(self.parent().newWF)
 
     def init_labels(self):
         self.label_layout.addWidget(self.status_label)
@@ -806,13 +806,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.syn_checkbox)
+        mid_layout.addWidget(self.comp_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.syn_checkbox.setLayoutDirection(Qt.RightToLeft)
+        self.comp_checkbox.setLayoutDirection(Qt.RightToLeft)
         self.label_layout.setStretch(0, 4)
         self.label_layout.setStretch(1, 0)
         self.label_layout.setStretch(2, 0)
@@ -827,7 +827,7 @@ class WaveformWidgetPG(QtWidgets.QWidget):
             label = QtWidgets.QLabel()
             self.perm_labels.append(label)
         self.qcombo_processed = QtWidgets.QComboBox()
-        self.syn_checkbox = QtWidgets.QCheckBox('synthetics')
+        self.comp_checkbox = QtWidgets.QCheckBox('Load comparison data')
         self.addQCboxItem('processed', 'green')
         self.addQCboxItem('raw', 'black')
         # self.perm_qcbox_right.setAlignment(2)
@@ -836,9 +836,11 @@ class WaveformWidgetPG(QtWidgets.QWidget):
     def getPlotDict(self):
         return self.plotdict
 
-    def activateObspyDMToptions(self, activate):
+    def activateObspyDMToptions(self, activate: bool) -> None:
-        self.syn_checkbox.setVisible(activate)
+        self.qcombo_processed.setEnabled(activate)
-        self.qcombo_processed.setVisible(activate)
+
+    def activateCompareOptions(self, activate: bool) -> None:
+        self.comp_checkbox.setEnabled(activate)
 
     def setPermText(self, number, text=None, color='black'):
         if not 0 <= number < len(self.perm_labels):
@@ -961,7 +963,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 for index, datum in enumerate(trace_syn.data)
+                trace_syn.data = np.array([datum + n + shift_syn 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))
@@ -1150,12 +1152,12 @@ class PylotCanvas(FigureCanvas):
         ax.set_xlim(self.cur_xlim)
         ax.set_ylim(self.cur_ylim)
         self.refreshPickDlgText()
-        ax.figure.canvas.draw()
+        ax.figure.canvas.draw_idle()
 
     def panRelease(self, gui_event):
         self.press = None
         self.press_rel = None
-        self.figure.canvas.draw()
+        self.figure.canvas.draw_idle()
 
     def panZoom(self, gui_event, threshold=2., factor=1.1):
         if not gui_event.x and not gui_event.y:
@@ -1373,11 +1375,15 @@ class PylotCanvas(FigureCanvas):
             plot_positions[channel] = plot_pos
         return plot_positions
 
-    def plotWFData(self, wfdata, title=None, zoomx=None, zoomy=None,
+    def plotWFData(self, wfdata, wfdata_compare=None, 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()
 
@@ -1388,21 +1394,33 @@ 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])
 
-            st_select = wfdata.select(component=component)
+            plot_streams['wfdata']['data'] = wfdata.select(component=component)
-            st_select += wfdata.select(component=alter_comp)
+            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)
         else:
-            st_select = wfdata
+            plot_streams['wfdata']['data'] = wfdata
+            if wfdata_compare:
+                plot_streams['wfdata_comp']['data'] = wfdata_compare
+
+        st_main = plot_streams['wfdata']['data']
 
         if mapping:
-            plot_positions = self.calcPlotPositions(st_select, compclass)
+            plot_positions = self.calcPlotPositions(st_main, compclass)
 
         # list containing tuples of network, station, channel and plot position (for sorting)
         nslc = []
-        for plot_pos, trace in enumerate(st_select):
+        for plot_pos, trace in enumerate(st_main):
             if not trace.stats.channel[-1] in ['Z', 'N', 'E', '1', '2', '3']:
                 print('Warning: Unrecognized channel {}'.format(trace.stats.channel))
                 continue
@@ -1410,44 +1428,48 @@ 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('.')
-            st = st_select.select(id=seed_id)
+            for wf_name, wf_dict in plot_streams.items():
-            trace = st[0].copy()
+                st_select = wf_dict.get('data')
-            if mapping:
+                if not st_select:
-                n = plot_positions[trace.stats.channel]
+                    continue
-            if n > nmax:
+                st = st_select.select(id=seed_id)
-                nmax = n
+                trace = st[0].copy()
-            if verbosity:
+                if mapping:
-                msg = 'plotting %s channel of station %s' % (channel, station)
+                    n = plot_positions[trace.stats.channel]
-                print(msg)
+                if n > nmax:
-            stime = trace.stats.starttime - wfstart
+                    nmax = n
-            time_ax = prep_time_axis(stime, trace)
+                if verbosity:
-            if time_ax is not None:
+                    msg = 'plotting %s channel of station %s' % (channel, station)
-                if scaleToChannel:
+                    print(msg)
-                    st_scale = wfdata.select(channel=scaleToChannel)
+                stime = trace.stats.starttime - wfstart
-                    if st_scale:
+                time_ax = prep_time_axis(stime, trace)
-                        tr = st_scale[0]
+                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:
                         trace.detrend('constant')
-                        trace.normalize(np.max(np.abs(tr.data)) * 2)
+                        trace.normalize(np.max(np.abs(trace.data)) * 2)
-                        scaleddata = True
-                if not scaleddata:
-                    trace.detrend('constant')
-                    trace.normalize(np.max(np.abs(trace.data)) * 2)
 
-                times = [time for index, time in enumerate(time_ax) if not index % nth_sample]
+                    offset = wf_dict.get('offset')
-                data = [datum + n for index, datum in enumerate(trace.data) if not index % nth_sample]
+
-                ax.axhline(n, color="0.5", lw=0.5)
+                    times = [time for index, time in enumerate(time_ax) if not index % nth_sample]
-                ax.plot(times, data, color=linecolor, linewidth=0.7)
+                    data = [datum + n + offset for index, datum in enumerate(trace.data) if not index % nth_sample]
-                if noiselevel is not None:
+                    ax.axhline(n, color="0.5", lw=0.5)
-                    for level in [-noiselevel[channel], noiselevel[channel]]:
+                    ax.plot(times, data, color=wf_dict.get('linecolor'), **wf_dict.get('plot_kwargs'))
-                        ax.plot([time_ax[0], time_ax[-1]],
+                    if noiselevel is not None:
-                                [n + level, n + level],
+                        for level in [-noiselevel[channel], noiselevel[channel]]:
-                                color=linecolor,
+                            ax.plot([time_ax[0], time_ax[-1]],
-                                linestyle='dashed')
+                                    [n + level, n + level],
-                self.setPlotDict(n, seed_id)
+                                    color=wf_dict.get('linecolor'),
+                                    linestyle='dashed')
+                    self.setPlotDict(n, seed_id)
         if plot_additional and additional_channel:
             compare_stream = wfdata.select(channel=additional_channel)
             if compare_stream:
@@ -1576,6 +1598,8 @@ class SearchFileByExtensionDialog(QtWidgets.QDialog):
         self.events = events
         self.filepaths = []
         self.file_extensions = []
+        self.check_all_state = True
+        self.merge_strategy = None
         self.default_text = default_text
         self.label = label
         self.setButtons()
@@ -1583,16 +1607,17 @@ class SearchFileByExtensionDialog(QtWidgets.QDialog):
         self.connectSignals()
         self.showPaths()
         self.refreshSelectionBox()
-        self.refresh_timer = QTimer(self)
+        # self.refresh_timer = QTimer(self)
-        self.refresh_timer.timeout.connect(self.showPaths)
+        # self.refresh_timer.timeout.connect(self.showPaths)
-        self.refresh_timer.start(10000)
+        # self.refresh_timer.start(10000)
 
         self.resize(800, 450)
 
-
     def setupUi(self):
+        ncol = 4
         self.main_layout = QtWidgets.QVBoxLayout()
         self.header_layout = QtWidgets.QHBoxLayout()
+        self.footer_layout = QtWidgets.QHBoxLayout()
         #
         self.setLayout(self.main_layout)
 
@@ -1606,11 +1631,24 @@ class SearchFileByExtensionDialog(QtWidgets.QDialog):
         self.searchButton = QtWidgets.QPushButton('Search')
         self.searchButton.setVisible(False)
 
+        # check/uncheck button for table
+        self.checkAllButton = QtWidgets.QPushButton('Check/Uncheck all')
+
+        # radiobutton for merge selection
+        self.mergeRadioButtonGroup = QtWidgets.QButtonGroup()
+        self.merge_button = QtWidgets.QRadioButton('Merge')
+        self.overwrite_button = QtWidgets.QRadioButton('Overwrite')
+        self.mergeRadioButtonGroup.addButton(self.merge_button)
+        self.mergeRadioButtonGroup.addButton(self.overwrite_button)
+        self.merge_button.setChecked(True)
+        self.merge_strategy = self.merge_button.text()
+
+        # table
         self.tableWidget = QtWidgets.QTableWidget()
         tableWidget = self.tableWidget
-        tableWidget.setColumnCount(3)
+        tableWidget.setColumnCount(ncol)
         tableWidget.setRowCount(len(self.events))
-        tableWidget.setHorizontalHeaderLabels(('Event ID', 'Filename', 'Last modified'))
+        tableWidget.setHorizontalHeaderLabels(('', 'Event ID', 'Filename', 'Last modified'))
         tableWidget.setEditTriggers(tableWidget.NoEditTriggers)
         tableWidget.setSortingEnabled(True)
         header = tableWidget.horizontalHeader()
@@ -1623,9 +1661,17 @@ class SearchFileByExtensionDialog(QtWidgets.QDialog):
         self.header_layout.addWidget(self.comboBox)
         self.header_layout.addWidget(self.searchButton)
 
+        self.footer_layout.addWidget(self.checkAllButton)
+        self.footer_layout.addWidget(self.statusText)
+        self.footer_layout.addWidget(self.merge_button)
+        self.footer_layout.addWidget(self.overwrite_button)
+
+        self.footer_layout.setStretch(0, 0)
+        self.footer_layout.setStretch(1, 1)
+
         self.main_layout.addLayout(self.header_layout)
         self.main_layout.addWidget(self.tableWidget)
-        self.main_layout.addWidget(self.statusText)
+        self.main_layout.addLayout(self.footer_layout)
         self.main_layout.addWidget(self._buttonbox)
 
     def showPaths(self):
@@ -1634,23 +1680,23 @@ class SearchFileByExtensionDialog(QtWidgets.QDialog):
         self.tableWidget.clearContents()
         for index, event in enumerate(self.events):
             filename = get_pylot_eventfile_with_extension(event, fext)
-            self.tableWidget.setItem(index, 0, QtWidgets.QTableWidgetItem(f'{event.pylot_id}'))
+            pf_selected_item = QtWidgets.QTableWidgetItem()
+            check_state = QtCore.Qt.Checked if filename else QtCore.Qt.Unchecked
+            pf_selected_item.setCheckState(check_state)
+            self.tableWidget.setItem(index, 0, pf_selected_item)
+            self.tableWidget.setItem(index, 1, QtWidgets.QTableWidgetItem(f'{event.pylot_id}'))
             if filename:
                 self.filepaths.append(filename)
                 ts = int(os.path.getmtime(filename))
 
                 # create QTableWidgetItems of filepath and last modification time
                 fname_item = QtWidgets.QTableWidgetItem(f'{os.path.split(filename)[-1]}')
+                fname_item.setData(3, filename)
                 ts_item = QtWidgets.QTableWidgetItem(f'{datetime.datetime.fromtimestamp(ts)}')
-                self.tableWidget.setItem(index, 1, fname_item)
+                self.tableWidget.setItem(index, 2, fname_item)
-                self.tableWidget.setItem(index, 2, ts_item)
+                self.tableWidget.setItem(index, 3, ts_item)
 
-        # TODO: Idea -> only refresh if table contents changed. Use selection to load only a subset of files
+        self.update_status()
-        if len(self.filepaths) > 0:
-            status_text = f'Found {len(self.filepaths)} eventfiles. Do you want to load them?'
-        else:
-            status_text = 'Did not find any files for specified file mask.'
-        self.statusText.setText(status_text)
 
     def refreshSelectionBox(self):
         fext = self.comboBox.currentText()
@@ -1670,12 +1716,52 @@ class SearchFileByExtensionDialog(QtWidgets.QDialog):
         self._buttonbox = QDialogButtonBox(QDialogButtonBox.Ok |
                                            QDialogButtonBox.Cancel)
 
+    def toggleCheckAll(self):
+        self.check_all_state = not self.check_all_state
+        self.checkAll(self.check_all_state)
+
+    def checkAll(self, state):
+        state = QtCore.Qt.Checked if state else QtCore.Qt.Unchecked
+        for row_ind in range(self.tableWidget.rowCount()):
+            item = self.tableWidget.item(row_ind, 0)
+            item.setCheckState(state)
+
+    def getChecked(self):
+        filepaths = []
+        for row_ind in range(self.tableWidget.rowCount()):
+            item_check = self.tableWidget.item(row_ind, 0)
+            if item_check.checkState() == QtCore.Qt.Checked:
+                item_fname = self.tableWidget.item(row_ind, 2)
+                if item_fname:
+                    filepath = item_fname.data(3)
+                    filepaths.append(filepath)
+        return filepaths
+
+    def update_status(self, row=None, col=None):
+        if col is not None and col != 0:
+            return
+        filepaths = self.getChecked()
+        if len(filepaths) > 0:
+            status_text = f"Found {len(filepaths)} eventfile{'s' if len(filepaths) > 1 else ''}. Do you want to load them?"
+        else:
+            status_text = 'Did not find/select any files for specified file mask.'
+        self.statusText.setText(status_text)
+
+    def update_merge_strategy(self):
+        for button in (self.merge_button, self.overwrite_button):
+            if button.isChecked():
+                self.merge_strategy = button.text()
+
     def connectSignals(self):
         self._buttonbox.accepted.connect(self.accept)
         self._buttonbox.rejected.connect(self.reject)
         self.comboBox.editTextChanged.connect(self.showPaths)
         self.searchButton.clicked.connect(self.showPaths)
-
+        self.checkAllButton.clicked.connect(self.toggleCheckAll)
+        self.checkAllButton.clicked.connect(self.update_status)
+        self.tableWidget.cellClicked.connect(self.update_status)
+        self.merge_button.clicked.connect(self.update_merge_strategy)
+        self.overwrite_button.clicked.connect(self.update_merge_strategy)
 
 
 class SingleTextLineDialog(QtWidgets.QDialog):
@@ -1782,8 +1868,8 @@ class PhaseDefaults(QtWidgets.QDialog):
 class PickDlg(QDialog):
     update_picks = QtCore.Signal(dict)
 
-    def __init__(self, parent=None, data=None, station=None, network=None, location=None, picks=None,
+    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,
+                 autopicks=None, rotate=False, parameter=None, embedded=False, metadata=None, show_comp_data=False,
                  event=None, filteroptions=None, model=None, wftype=None):
         super(PickDlg, self).__init__(parent, Qt.Window)
         self.orig_parent = parent
@@ -1792,6 +1878,7 @@ 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
@@ -1830,22 +1917,6 @@ class PickDlg(QDialog):
         else:
             self.filteroptions = FILTERDEFAULTS
         self.pick_block = False
-        self.nextStation = QtWidgets.QCheckBox('Continue with next station ')
-
-        # comparison channel
-        self.compareChannel = QtWidgets.QComboBox()
-        self.compareChannel.activated.connect(self.resetPlot)
-
-        # scale channel
-        self.scaleChannel = QtWidgets.QComboBox()
-        self.scaleChannel.activated.connect(self.resetPlot)
-
-        # initialize panning attributes
-        self.press = None
-        self.xpress = None
-        self.ypress = None
-        self.cur_xlim = None
-        self.cur_ylim = None
 
         # set attribute holding data
         if data is None or not data:
@@ -1858,6 +1929,31 @@ class PickDlg(QDialog):
                 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))
+
+        # scale channel
+        self.scaleChannel = QtWidgets.QComboBox()
+        self.scaleChannel.activated.connect(self.resetPlot)
+
+        # initialize panning attributes
+        self.press = None
+        self.xpress = None
+        self.ypress = None
+        self.cur_xlim = None
+        self.cur_ylim = None
 
         self.stime, self.etime = full_range(self.getWFData())
 
@@ -1870,12 +1966,12 @@ class PickDlg(QDialog):
         self.setupUi()
 
         # fill compare and scale channels
-        self.compareChannel.addItem('-', None)
+        self.referenceChannel.addItem('-', None)
         self.scaleChannel.addItem('individual', None)
 
         for trace in self.getWFData():
             channel = trace.stats.channel
-            self.compareChannel.addItem(channel, trace)
+            self.referenceChannel.addItem(channel, trace)
             if not channel[-1] in ['Z', 'N', 'E', '1', '2', '3']:
                 print('Skipping unknown channel for scaling: {}'.format(channel))
                 continue
@@ -1892,7 +1988,7 @@ class PickDlg(QDialog):
         if self.wftype is not None:
             title += ' | ({})'.format(self.wftype)
 
-        self.multicompfig.plotWFData(wfdata=self.getWFData(),
+        self.multicompfig.plotWFData(wfdata=self.getWFData(), wfdata_compare=self.getWFDataComp(),
                                      title=title)
 
         self.multicompfig.setZoomBorders2content()
@@ -2068,8 +2164,11 @@ class PickDlg(QDialog):
         _dialtoolbar.addWidget(est_label)
         _dialtoolbar.addWidget(self.plot_arrivals_button)
         _dialtoolbar.addSeparator()
-        _dialtoolbar.addWidget(QtWidgets.QLabel('Compare to channel: '))
+        _dialtoolbar.addWidget(QtWidgets.QLabel('Plot reference channel: '))
-        _dialtoolbar.addWidget(self.compareChannel)
+        _dialtoolbar.addWidget(self.referenceChannel)
+        _dialtoolbar.addSeparator()
+        _dialtoolbar.addWidget(QtWidgets.QLabel('Compare: '))
+        _dialtoolbar.addWidget(self.compareCB)
         _dialtoolbar.addSeparator()
         _dialtoolbar.addWidget(QtWidgets.QLabel('Scaling: '))
         _dialtoolbar.addWidget(self.scaleChannel)
@@ -2154,10 +2253,12 @@ class PickDlg(QDialog):
         station_id = trace.get_id()
         starttime = trace.stats.starttime
         station_coords = self.metadata.get_coordinates(station_id, starttime)
+        if not station_coords:
+            print('get_arrivals: No station coordinates found. Return!')
+            return
         origins = self.pylot_event.origins
         if phases == ['None', 'None']:
-            print("get_arrivals: Creation info (manual or auto) not available!")
+            print("get_arrivals: Creation info (manual or auto) not available! Return!")
-            print("Return!")
             return
         if origins:
             source_origin = origins[0]
@@ -2404,7 +2505,7 @@ class PickDlg(QDialog):
     def activatePicking(self):
         self.leave_rename_phase()
         self.renamePhaseAction.setEnabled(False)
-        self.compareChannel.setEnabled(False)
+        self.referenceChannel.setEnabled(False)
         self.scaleChannel.setEnabled(False)
         phase = self.currentPhase
         phaseID = self.getPhaseID(phase)
@@ -2436,7 +2537,7 @@ class PickDlg(QDialog):
         self.disconnectPressEvent()
         self.multicompfig.connectEvents()
         self.renamePhaseAction.setEnabled(True)
-        self.compareChannel.setEnabled(True)
+        self.referenceChannel.setEnabled(True)
         self.scaleChannel.setEnabled(True)
         self.connect_pick_delete()
         self.draw()
@@ -2509,6 +2610,12 @@ 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()
@@ -2630,11 +2737,16 @@ class PickDlg(QDialog):
 
         stime = self.getStartTime()
 
-        # copy data for plotting
+        # copy wfdata for plotting
-        data = self.getWFData().copy()
+        wfdata = self.getWFData().copy()
-        data = self.getPickPhases(data, phase)
+        wfdata_comp = self.getWFDataComp().copy()
-        data.normalize()
+        wfdata = self.getPickPhases(wfdata, phase)
-        if not data:
+        wfdata_comp = self.getPickPhases(wfdata_comp, phase)
+        for wfd in [wfdata, wfdata_comp]:
+            if wfd:
+                wfd.normalize()
+
+        if not wfdata:
             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 '
@@ -2642,14 +2754,16 @@ class PickDlg(QDialog):
             self.leave_picking_mode()
             return
 
-        # filter data and trace on which is picked prior to determination of SNR
+        # filter wfdata and trace on which is picked prior to determination of SNR
         filterphase = self.currentFilterPhase()
         if filterphase:
             filteroptions = self.getFilterOptions(filterphase).parseFilterOptions()
             try:
-                data.detrend('linear')
+                for wfd in [wfdata, wfdata_comp]:
-                data.filter(**filteroptions)
+                    if wfd:
-                # wfdata.filter(**filteroptions)# MP MP removed filtering of original data
+                        wfd.detrend('linear')
+                        wfd.filter(**filteroptions)
+                # wfdata.filter(**filteroptions)# MP MP removed filtering of original wfdata
             except ValueError as e:
                 self.qmb = QtWidgets.QMessageBox(QtWidgets.QMessageBox.Icon.Information,
                                                  'Denied',
@@ -2659,8 +2773,8 @@ class PickDlg(QDialog):
         snr = []
         noiselevels = {}
         # determine SNR and noiselevel
-        for trace in data.traces:
+        for trace in wfdata.traces:
-            st = data.select(channel=trace.stats.channel)
+            st = wfdata.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])
@@ -2671,23 +2785,25 @@ class PickDlg(QDialog):
                 noiselevel = nfac
             noiselevels[trace.stats.channel] = noiselevel
 
-        # prepare plotting of data
+        # prepare plotting of wfdata
-        for trace in data:
+        for wfd in [wfdata, wfdata_comp]:
-            t = prep_time_axis(trace.stats.starttime - stime, trace)
+            if wfd:
-            inoise = getnoisewin(t, ini_pick, noise_win, gap_win)
+                for trace in wfd:
-            trace = demeanTrace(trace, inoise)
+                    t = prep_time_axis(trace.stats.starttime - stime, trace)
-            # upscale trace data in a way that each trace is vertically zoomed to noiselevel*factor
+                    inoise = getnoisewin(t, ini_pick, noise_win, gap_win)
-            channel = trace.stats.channel
+                    trace = demeanTrace(trace, inoise)
-            noiselevel = noiselevels[channel]
+                    # upscale trace wfdata in a way that each trace is vertically zoomed to noiselevel*factor
-            noiseScaleFactor = self.calcNoiseScaleFactor(noiselevel, zoomfactor=5.)
+                    channel = trace.stats.channel
-            trace.data *= noiseScaleFactor
+                    noiselevel = noiselevels[channel]
-            noiselevels[channel] *= noiseScaleFactor
+                    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(data) - 1])
+        ylims = list(np.array([-.5, .5]) + [0, len(wfdata) - 1])
 
         title = self.getStation() + ' picking mode'
         title += ' | SNR: {}'.format(mean_snr)
@@ -2695,9 +2811,10 @@ class PickDlg(QDialog):
             filtops_str = transformFilteroptions2String(filteroptions)
             title += ' | Filteroptions: {}'.format(filtops_str)
 
-        plot_additional = bool(self.compareChannel.currentText())
+        plot_additional = bool(self.referenceChannel.currentText())
-        additional_channel = self.compareChannel.currentText()
+        additional_channel = self.referenceChannel.currentText()
-        self.multicompfig.plotWFData(wfdata=data,
+        self.multicompfig.plotWFData(wfdata=wfdata,
+                                     wfdata_compare=wfdata_comp,
                                      title=title,
                                      zoomx=xlims,
                                      zoomy=ylims,
@@ -3088,7 +3205,8 @@ class PickDlg(QDialog):
         self.cur_xlim = self.multicompfig.axes[0].get_xlim()
         self.cur_ylim = self.multicompfig.axes[0].get_ylim()
         # self.multicompfig.updateCurrentLimits()
-        data = self.getWFData().copy()
+        wfdata = self.getWFData().copy()
+        wfdata_comp = self.getWFDataComp().copy()
         title = self.getStation()
         if filter:
             filtoptions = None
@@ -3096,19 +3214,22 @@ class PickDlg(QDialog):
                 filtoptions = self.getFilterOptions(self.getPhaseID(phase), gui_filter=True).parseFilterOptions()
 
             if filtoptions is not None:
-                data.detrend('linear')
+                for wfd in [wfdata, wfdata_comp]:
-                data.taper(0.02, type='cosine')
+                    if wfd:
-                data.filter(**filtoptions)
+                        wfd.detrend('linear')
+                        wfd.taper(0.02, type='cosine')
+                        wfd.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.compareChannel.currentText())
+        plot_additional = bool(self.referenceChannel.currentText())
-        additional_channel = self.compareChannel.currentText()
+        additional_channel = self.referenceChannel.currentText()
         scale_channel = self.scaleChannel.currentText()
-        self.multicompfig.plotWFData(wfdata=data, title=title,
+        self.multicompfig.plotWFData(wfdata=wfdata, wfdata_compare=wfdata_comp,
+                                     title=title,
                                      zoomx=self.getXLims(),
                                      zoomy=self.getYLims(),
                                      plot_additional=plot_additional,
@@ -3181,6 +3302,9 @@ 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)
@@ -3792,11 +3916,13 @@ 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),
@@ -3881,7 +4007,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()
+            canvas.draw_idle()
 
     def plot_manual_pick_to_ax(self, ax, picks, phase, starttime, quality):
         mpp = picks[phase]['mpp'] - starttime