refactor: remove unused methods

autoPyLoT.py

@@ -243,7 +243,7 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even
                 pylot_event = Event(eventpath)  # event should be path to event directory
                 data.setEvtData(pylot_event)
             if fnames == 'None':
-                data.setWFData(glob.glob(os.path.join(datapath, event_datapath, '*')))
+                data.set_wf_data(glob.glob(os.path.join(datapath, event_datapath, '*')))
                 # the following is necessary because within
                 # multiple event processing no event ID is provided
                 # in autopylot.in
@@ -258,7 +258,7 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even
                                                       now.minute)
                     parameter.setParam(eventID=eventID)
             else:
-                data.setWFData(fnames)
+                data.set_wf_data(fnames)
 
                 eventpath = events[0]
                 # now = datetime.datetime.now()
@@ -268,7 +268,7 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even
                 #                               now.hour,
                 #                               now.minute)
                 parameter.setParam(eventID=eventid)
-            wfdat = data.getWFData()  # all available streams
+            wfdat = data.get_wf_data()  # all available streams
             if not station == 'all':
                 wfdat = wfdat.select(station=station)
                 if not wfdat:

pylot/core/io/data.py

@@ -1,660 +1,69 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-import copy
-import logging
 import os
+from dataclasses import dataclass, field
+from typing import List, Union
 
-from PySide2.QtWidgets import QMessageBox
+from obspy import UTCDateTime
-from obspy import read_events
-from obspy.core import read, Stream, UTCDateTime
-from obspy.core.event import Event as ObsPyEvent
-from obspy.io.sac import SacIOError
 
-import pylot.core.loc.focmec as focmec
+from pylot.core.io.event import EventData
-import pylot.core.loc.hypodd as hypodd
+from pylot.core.io.waveformdata import WaveformData
-import pylot.core.loc.velest as velest
+from pylot.core.util.dataprocessing import Metadata
-from pylot.core.io.phases import readPILOTEvent, picks_from_picksdict, \
-    picksdict_from_pilot, merge_picks, PylotParameter
-from pylot.core.util.errors import FormatError, OverwriteError
-from pylot.core.util.event import Event
-from pylot.core.util.obspyDMT_interface import qml_from_obspyDMT
-from pylot.core.util.utils import fnConstructor, full_range, check4rotated, \
-    check_for_gaps_and_merge, trim_station_components, check_for_nan
 
-
+@dataclass
-class Data(object):
+class Data:
-    """
+    event_data: EventData = field(default_factory=EventData)
-    Data container with attributes wfdata holding ~obspy.core.stream.
+    waveform_data: WaveformData = field(default_factory=WaveformData)
-
+    metadata: Metadata = field(default_factory=Metadata)
-    :type parent: PySide2.QtWidgets.QWidget object, optional
+    _parent: Union[None, 'QtWidgets.QWidget'] = None
-    :param parent: A PySide2.QtWidgets.QWidget object utilized when
-    called by a GUI to display a PySide2.QtWidgets.QMessageBox instead of printing
-    to standard out.
-    :type evtdata: ~obspy.core.event.Event object, optional
-    :param evtdata ~obspy.core.event.Event object containing all derived or
-    loaded event. Container object holding, e.g. phase arrivals, etc.
-    """
 
     def __init__(self, parent=None, evtdata=None):
         self._parent = parent
-        if self.getParent():
+        self.event_data = EventData(evtdata)
-            self.comp = parent.getComponent()
+        self.waveform_data = WaveformData()
-        else:
-            self.comp = 'Z'
-            self.wfdata = Stream()
-        self._new = False
-        if isinstance(evtdata, ObsPyEvent) or isinstance(evtdata, Event):
-            pass
-        elif isinstance(evtdata, dict):
-            evt = readPILOTEvent(**evtdata)
-            evtdata = evt
-        elif isinstance(evtdata, str):
-            try:
-                cat = read_events(evtdata)
-                if len(cat) != 1:
-                    raise ValueError('ambiguous event information for file: '
-                                     '{file}'.format(file=evtdata))
-                evtdata = cat[0]
-            except TypeError as e:
-                if 'Unknown format for file' in e.message:
-                    if 'PHASES' in evtdata:
-                        picks = picksdict_from_pilot(evtdata)
-                        evtdata = ObsPyEvent()
-                        evtdata.picks = picks_from_picksdict(picks)
-                    elif 'LOC' in evtdata:
-                        raise NotImplementedError('PILOT location information '
-                                                  'read support not yet '
-                                                  'implemented.')
-                    elif 'event.pkl' in evtdata:
-                        evtdata = qml_from_obspyDMT(evtdata)
-                    else:
-                        raise e
-                else:
-                    raise e
-        else:  # create an empty Event object
-            self.setNew()
-            evtdata = ObsPyEvent()
-            evtdata.picks = []
-        self.evtdata = evtdata
-        self.wforiginal = None
-        self.cuttimes = None
-        self.dirty = False
-        self.processed = None
 
     def __str__(self):
-        return str(self.wfdata)
+        return str(self.waveform_data.wfdata)
 
     def __add__(self, other):
-        assert isinstance(other, Data), "operands must be of same type 'Data'"
+        if not isinstance(other, Data):
-        rs_id = self.get_evt_data().get('resource_id')
+            raise TypeError("Operands must be of type 'Data'")
-        rs_id_other = other.get_evt_data().get('resource_id')
+        if self.event_data.is_new() and other.event_data.is_new():
-        if other.isNew() and not self.isNew():
-            picks_to_add = other.get_evt_data().picks
-            old_picks = self.get_evt_data().picks
-            wf_ids_old = [pick.waveform_id for pick in old_picks]
-            for new_pick in picks_to_add:
-                wf_id = new_pick.waveform_id
-                if wf_id in wf_ids_old:
-                    for old_pick in old_picks:
-                        comparison = [old_pick.waveform_id == new_pick.waveform_id,
-                                      old_pick.phase_hint == new_pick.phase_hint,
-                                      old_pick.method_id == new_pick.method_id]
-                        if all(comparison):
-                            del (old_pick)
-                old_picks.append(new_pick)
-        elif not other.isNew() and self.isNew():
-            new = other + self
-            self.evtdata = new.get_evt_data()
-        elif self.isNew() and other.isNew():
             pass
-        elif rs_id == rs_id_other:
+        elif other.event_data.is_new():
-            other.setNew()
+            new_picks = other.event_data.evtdata.picks
+            old_picks = self.event_data.evtdata.picks
+            old_picks.extend([pick for pick in new_picks if pick not in old_picks])
+        elif self.event_data.is_new():
+            return other + self
+        elif self.event_data.get_id() == other.event_data.get_id():
+            other.event_data.set_new()
             return self + other
         else:
-            raise ValueError("both Data objects have differing "
+            raise ValueError("Both Data objects have differing unique Event identifiers")
-                             "unique Event identifiers")
         return self
 
-    def getPicksStr(self):
+    def get_parent(self):
-        """
-        Return picks in event data
-        :return: picks seperated by newlines
-        :rtype: str
-        """
-        picks_str = ''
-        for pick in self.get_evt_data().picks:
-            picks_str += str(pick) + '\n'
-        return picks_str
-
-    def getParent(self):
-        """
-        Get PySide.QtGui.QWidget parent object
-        """
         return self._parent
 
-    def isNew(self):
+    def filter_wf_data(self, **kwargs):
-        return self._new
+        self.waveform_data.wfdata.detrend('linear')
+        self.waveform_data.wfdata.taper(0.02, type='cosine')
+        self.waveform_data.wfdata.filter(**kwargs)
+        self.waveform_data.dirty = True
 
-    def setNew(self):
+    def set_wf_data(self, fnames: List[str], fnames_alt: List[str] = None, check_rotated=False, metadata=None, tstart=0, tstop=0):
-        self._new = True
+        return self.waveform_data.load_waveforms(fnames, fnames_alt, check_rotated, metadata, tstart, tstop)
 
-    def getCutTimes(self):
+    def reset_wf_data(self):
-        """
+        self.waveform_data.reset()
-        Returns earliest start and latest end of all waveform data
-        :return: minimum start time and maximum end time as a tuple
-        :rtype: (UTCDateTime, UTCDateTime)
-        """
-        if self.cuttimes is None:
-            self.updateCutTimes()
-        return self.cuttimes
 
-    def updateCutTimes(self):
+    def get_wf_data(self):
-        """
+        return self.waveform_data.wfdata
-        Update cuttimes to contain earliest start and latest end time
-        of all waveform data
-        :rtype: None
-        """
-        self.cuttimes = full_range(self.getWFData())
 
-    def getEventFileName(self):
+    def rotate_wf_data(self):
-        ID = self.getID()
+        self.waveform_data.rotate_zne(self.metadata)
-        # handle forbidden filenames especially on windows systems
-        return fnConstructor(str(ID))
-
-    def checkEvent(self, event, fcheck, forceOverwrite=False):
-        """
-        Check information in supplied event and own event and replace with own
-        information if no other information are given or forced by forceOverwrite
-        :param event: Event that supplies information for comparison
-        :type event: pylot.core.util.event.Event
-        :param fcheck: check and delete existing information
-        can be a str or a list of strings of ['manual', 'auto', 'origin', 'magnitude']
-        :type fcheck: str, [str]
-        :param forceOverwrite: Set to true to force overwrite own information. If false,
-        supplied information from event is only used if there is no own information in that
-        category (given in fcheck: manual, auto, origin, magnitude)
-        :type forceOverwrite: bool
-        :return:
-        :rtype: None
-        """
-        if 'origin' in fcheck:
-            self.replaceOrigin(event, forceOverwrite)
-        if 'magnitude' in fcheck:
-            self.replaceMagnitude(event, forceOverwrite)
-        if 'auto' in fcheck:
-            self.replacePicks(event, 'auto')
-        if 'manual' in fcheck:
-            self.replacePicks(event, 'manual')
-
-    def replaceOrigin(self, event, forceOverwrite=False):
-        """
-        Replace own origin with the one supplied in event if own origin is not
-        existing or forced by forceOverwrite = True
-        :param event: Event that supplies information for comparison
-        :type event: pylot.core.util.event.Event
-        :param forceOverwrite: always replace own information with supplied one if true
-        :type forceOverwrite: bool
-        :return:
-        :rtype: None
-        """
-        if self.get_evt_data().origins or forceOverwrite:
-            if event.origins:
-                print("Found origin, replace it by new origin.")
-            event.origins = self.get_evt_data().origins
-
-    def replaceMagnitude(self, event, forceOverwrite=False):
-        """
-        Replace own magnitude with the one supplied in event if own magnitude is not
-        existing or forced by forceOverwrite = True
-        :param event: Event that supplies information for comparison
-        :type event: pylot.core.util.event.Event
-        :param forceOverwrite: always replace own information with supplied one if true
-        :type forceOverwrite: bool
-        :return:
-        :rtype: None
-        """
-        if self.get_evt_data().magnitudes or forceOverwrite:
-            if event.magnitudes:
-                print("Found magnitude, replace it by new magnitude")
-            event.magnitudes = self.get_evt_data().magnitudes
-
-    def replacePicks(self, event, picktype):
-        """
-        Replace picks in event with own picks
-        :param event: Event that supplies information for comparison
-        :type event: pylot.core.util.event.Event
-        :param picktype: 'auto' or 'manual' picks
-        :type picktype: str
-        :return:
-        :rtype: None
-        """
-        checkflag = 1
-        picks = event.picks
-        # remove existing picks
-        for j, pick in reversed(list(enumerate(picks))):
-            try:
-                if picktype in str(pick.method_id.id):
-                    picks.pop(j)
-                    checkflag = 2
-            except AttributeError as e:
-                msg = '{}'.format(e)
-                print(e)
-                checkflag = 0
-        if checkflag > 0:
-            if checkflag == 1:
-                print("Write new %s picks to catalog." % picktype)
-            if checkflag == 2:
-                print("Found %s pick(s), remove them and append new picks to catalog." % picktype)
-
-            # append new picks
-            for pick in self.get_evt_data().picks:
-                if picktype in str(pick.method_id.id):
-                    picks.append(pick)
-
-    def exportEvent(self, fnout, fnext='.xml', fcheck='auto', upperErrors=None):
-        """
-        Export event to file
-        :param fnout: basename of file
-        :param fnext: file extensions xml, cnv, obs, focmec, or/and pha
-        :param fcheck: check and delete existing information
-        can be a str or a list of strings of ['manual', 'auto', 'origin', 'magnitude']
-        """
-        from pylot.core.util.defaults import OUTPUTFORMATS
-        if not type(fcheck) == list:
-            fcheck = [fcheck]
-
-        try:
-            evtformat = OUTPUTFORMATS[fnext]
-        except KeyError as e:
-            errmsg = '{0}; selected file extension {1} not ' \
-                     'supported'.format(e, fnext)
-            raise FormatError(errmsg)
-
-        if hasattr(self.get_evt_data(), 'notes'):
-            try:
-                with open(os.path.join(os.path.dirname(fnout), 'notes.txt'), 'w') as notes_file:
-                    notes_file.write(self.get_evt_data().notes)
-            except Exception as e:
-                print('Warning: Could not save notes.txt: ', str(e))
-
-        # check for already existing xml-file
-        if fnext == '.xml':
-            if os.path.isfile(fnout + fnext):
-                print("xml-file already exists! Check content ...")
-                cat = read_events(fnout + fnext)
-                if len(cat) > 1:
-                    raise IOError('Ambigious event information in file {}'.format(fnout + fnext))
-                if len(cat) < 1:
-                    raise IOError('No event information in file {}'.format(fnout + fnext))
-                event = cat[0]
-                if not event.resource_id == self.get_evt_data().resource_id:
-                    QMessageBox.warning(self, 'Warning', 'Different resource IDs!')
-                    return
-                self.checkEvent(event, fcheck)
-                self.setEvtData(event)
-
-            self.get_evt_data().write(fnout + fnext, format=evtformat)
-
-        # try exporting event
-        else:
-            evtdata_org = self.get_evt_data()
-            picks = evtdata_org.picks
-            eventpath = evtdata_org.path
-            picks_copy = copy.deepcopy(picks)
-            evtdata_copy = Event(eventpath)
-            evtdata_copy.picks = picks_copy
-
-            # check for stations picked automatically as well as manually
-            # Prefer manual picks!
-            for i in range(len(picks)):
-                if picks[i].method_id == 'manual':
-                    mstation = picks[i].waveform_id.station_code
-                    mstation_ext = mstation + '_'
-                    for k in range(len(picks_copy)):
-                        if ((picks_copy[k].waveform_id.station_code == mstation) or
-                            (picks_copy[k].waveform_id.station_code == mstation_ext)) and \
-                                (picks_copy[k].method_id == 'auto'):
-                            del picks_copy[k]
-                            break
-            lendiff = len(picks) - len(picks_copy)
-            if lendiff != 0:
-                print("Manual as well as automatic picks available. Prefered the {} manual ones!".format(lendiff))
-
-
-            no_uncertainties_p = []
-            no_uncertainties_s = []
-            if upperErrors:
-                # check for pick uncertainties exceeding adjusted upper errors
-                # Picks with larger uncertainties will not be saved in output file!
-                for j in range(len(picks)):
-                    for i in range(len(picks_copy)):
-                        if picks_copy[i].phase_hint[0] == 'P':
-                            # Skipping pick if no upper_uncertainty is found and warning user
-                            if picks_copy[i].time_errors['upper_uncertainty'] is None:
-                                #print("{1} P-Pick of station {0} does not have upper_uncertainty and cant be checked".format(
-                                 #   picks_copy[i].waveform_id.station_code,
-                                  #  picks_copy[i].method_id))
-                                if not picks_copy[i].waveform_id.station_code in no_uncertainties_p:
-                                    no_uncertainties_p.append(picks_copy[i].waveform_id.station_code)
-                                continue
-
-                            #print ("checking for upper_uncertainty")
-                            if  (picks_copy[i].time_errors['uncertainty'] is None) or \
-                                    (picks_copy[i].time_errors['upper_uncertainty'] >= upperErrors[0]):
-                                print("Uncertainty exceeds or equal adjusted upper time error!")
-                                print("Adjusted uncertainty: {}".format(upperErrors[0]))
-                                print("Pick uncertainty: {}".format(picks_copy[i].time_errors['uncertainty']))
-                                print("{1} P-Pick of station {0} will not be saved in outputfile".format(
-                                    picks_copy[i].waveform_id.station_code,
-                                    picks_copy[i].method_id))
-                                del picks_copy[i]
-                                break
-                        if picks_copy[i].phase_hint[0] == 'S':
-
-                            # Skipping pick if no upper_uncertainty is found and warning user
-                            if picks_copy[i].time_errors['upper_uncertainty'] is None:
-                                #print("{1} S-Pick of station {0} does not have upper_uncertainty and cant be checked".format(
-                                    #picks_copy[i].waveform_id.station_code,
-                                    #picks_copy[i].method_id))
-                                if not picks_copy[i].waveform_id.station_code in no_uncertainties_s:
-                                    no_uncertainties_s.append(picks_copy[i].waveform_id.station_code)
-                                continue
-
-
-                            if (picks_copy[i].time_errors['uncertainty'] is None) or \
-                                (picks_copy[i].time_errors['upper_uncertainty'] >= upperErrors[1]):
-                                print("Uncertainty exceeds or equal adjusted upper time error!")
-                                print("Adjusted uncertainty: {}".format(upperErrors[1]))
-                                print("Pick uncertainty: {}".format(picks_copy[i].time_errors['uncertainty']))
-                                print("{1} S-Pick of station {0} will not be saved in outputfile".format(
-                                    picks_copy[i].waveform_id.station_code,
-                                    picks_copy[i].method_id))
-                                del picks_copy[i]
-                                break
-            for s in no_uncertainties_p:
-                print("P-Pick of station {0} does not have upper_uncertainty and cant be checked".format(s))
-            for s in no_uncertainties_s:
-                print("S-Pick of station {0} does not have upper_uncertainty and cant be checked".format(s))
-
-            if fnext == '.obs':
-                try:
-                    evtdata_copy.write(fnout + fnext, format=evtformat)
-                    # write header afterwards
-                    evid = str(evtdata_org.resource_id).split('/')[1]
-                    header = '# EQEVENT:  Label: EQ%s  Loc:  X 0.00  Y 0.00  Z 10.00  OT 0.00 \n' % evid
-                    nllocfile = open(fnout + fnext)
-                    l = nllocfile.readlines()
-                    # Adding A0/Generic Amplitude to .obs file
-                    # l2 = []
-                    # for li in l:
-                    #    for amp in evtdata_org.amplitudes:
-                    #        if amp.waveform_id.station_code == li[0:5].strip():
-                    #            li = li[0:64] + '{:0.2e}'.format(amp.generic_amplitude) + li[73:-1] + '\n'
-                    #            l2.append(li)
-                    # l = l2
-                    nllocfile.close()
-                    l.insert(0, header)
-                    nllocfile = open(fnout + fnext, 'w')
-                    nllocfile.write("".join(l))
-                    nllocfile.close()
-                except KeyError as e:
-                    raise KeyError('''{0} export format
-                                     not implemented: {1}'''.format(evtformat, e))
-            if fnext == '.cnv':
-                try:
-                    velest.export(picks_copy, fnout + fnext, eventinfo=self.get_evt_data())
-                except KeyError as e:
-                    raise KeyError('''{0} export format
-                                     not implemented: {1}'''.format(evtformat, e))
-            if fnext == '_focmec.in':
-                try:
-                    parameter = PylotParameter()
-                    logging.warning('Using default input parameter')
-                    focmec.export(picks_copy, fnout + fnext, parameter, eventinfo=self.get_evt_data())
-                except KeyError as e:
-                    raise KeyError('''{0} export format
-                                     not implemented: {1}'''.format(evtformat, e))
-            if fnext == '.pha':
-                try:
-                    parameter = PylotParameter()
-                    logging.warning('Using default input parameter')
-                    hypodd.export(picks_copy, fnout + fnext, parameter, eventinfo=self.get_evt_data())
-                except KeyError as e:
-                    raise KeyError('''{0} export format
-                                     not implemented: {1}'''.format(evtformat, e))
-
-    def getComp(self):
-        """
-        Get component (ZNE)
-        """
-        return self.comp
-
-    def getID(self):
-        """
-        Get unique resource id
-        """
-        try:
-            return self.evtdata.get('resource_id').id
-        except:
-            return None
-
-    def filterWFData(self, kwargs):
-        """
-        Filter waveform data
-        :param kwargs: arguments to pass through to filter function
-        """
-        data = self.getWFData()
-        data.detrend('linear')
-        data.taper(0.02, type='cosine')
-        data.filter(**kwargs)
-        self.dirty = True
-
-    def setWFData(self, fnames, fnames_alt=None, checkRotated=False, metadata=None, tstart=0, tstop=0):
-        """
-        Clear current waveform data and set given waveform data
-        :param fnames: waveform data names to append
-        :param fnames_alt: alternative data to show (e.g. synthetic/processed)
-        :type fnames: list
-        """
-        def check_fname_exists(filenames: list) -> list:
-            if filenames:
-                filenames = [fn for fn in filenames if os.path.isfile(fn)]
-            return filenames
-
-        self.wfdata = Stream()
-        self.wforiginal = None
-        self.wf_alt = Stream()
-        if tstart == tstop:
-            tstart = tstop = None
-        self.tstart = tstart
-        self.tstop = tstop
-
-        # remove directories
-        fnames = check_fname_exists(fnames)
-        fnames_alt = check_fname_exists(fnames_alt)
-
-        # if obspy_dmt:
-        #     wfdir = 'raw'
-        #     self.processed = False
-        #     for fname in fnames:
-        #         if fname.endswith('processed'):
-        #             wfdir = 'processed'
-        #             self.processed = True
-        #             break
-        #     for fpath in fnames:
-        #         if fpath.endswith(wfdir):
-        #             wffnames = [os.path.join(fpath, fname) for fname in os.listdir(fpath)]
-        #         if 'syngine' in fpath.split('/')[-1]:
-        #             wffnames_syn = [os.path.join(fpath, fname) for fname in os.listdir(fpath)]
-        # else:
-        #     wffnames = fnames
-        if fnames is not None:
-            self.appendWFData(fnames)
-            if fnames_alt is not None:
-                self.appendWFData(fnames_alt, alternative=True)
-        else:
-            return False
-
-        # various pre-processing steps:
-        # remove possible underscores in station names
-        # self.wfdata = remove_underscores(self.wfdata)
-        # check for gaps and merge
-        self.wfdata, _ = check_for_gaps_and_merge(self.wfdata)
-        # check for nans
-        check_for_nan(self.wfdata)
-        # check for stations with rotated components
-        if checkRotated and metadata is not None:
-            self.wfdata = check4rotated(self.wfdata, metadata, verbosity=0)
-        # trim station components to same start value
-        trim_station_components(self.wfdata, trim_start=True, trim_end=False)
-
-        # make a copy of original data
-        self.wforiginal = self.getWFData().copy()
-        self.dirty = False
-        return True
-
-    def appendWFData(self, fnames, alternative=False):
-        """
-        Read waveform data from fnames and append it to current wf data
-        :param fnames: waveform data to append
-        :type fnames: list
-        """
-        assert isinstance(fnames, list), "input parameter 'fnames' is " \
-                                         "supposed to be of type 'list' " \
-                                         "but is actually" \
-                                         " {0}".format(type(fnames))
-        if self.dirty:
-            self.resetWFData()
-
-        orig_or_alternative_data = {True: self.wf_alt,
-                                    False: self.wfdata}
-
-        warnmsg = ''
-        for fname in set(fnames):
-            try:
-                orig_or_alternative_data[alternative] += read(fname, starttime=self.tstart, endtime=self.tstop)
-            except TypeError:
-                try:
-                    orig_or_alternative_data[alternative] += read(fname, format='GSE2', starttime=self.tstart, endtime=self.tstop)
-                except Exception as e:
-                    try:
-                        orig_or_alternative_data[alternative] += read(fname, format='SEGY', starttime=self.tstart,
-                                                                      endtime=self.tstop)
-                    except Exception as e:
-                        warnmsg += '{0}\n{1}\n'.format(fname, e)
-            except SacIOError as se:
-                warnmsg += '{0}\n{1}\n'.format(fname, se)
-        if warnmsg:
-            warnmsg = 'WARNING in appendWFData: unable to read waveform data\n' + warnmsg
-            print(warnmsg)
-
-    def getWFData(self):
-        return self.wfdata
-
-    def getOriginalWFData(self):
-        return self.wforiginal
-
-    def getAltWFdata(self):
-        return self.wf_alt
-
-    def resetWFData(self):
-        """
-        Set waveform data to original waveform data
-        """
-        if self.getOriginalWFData():
-            self.wfdata = self.getOriginalWFData().copy()
-        else:
-            self.wfdata = Stream()
-        self.dirty = False
-
-    def resetPicks(self):
-        """
-        Clear all picks from event
-        """
-        self.get_evt_data().picks = []
-
-    def get_evt_data(self):
-        return self.evtdata
-
-    def setEvtData(self, event):
-        self.evtdata = event
-
-    def applyEVTData(self, data, typ='pick'):
-        """
-        Either takes an `obspy.core.event.Event` object and applies all new
-        information on the event to the actual data if typ is 'event or
-        creates ObsPy pick objects and append it to the picks list from the
-        PyLoT dictionary contain all picks if type is pick
-        :param data: data to apply, either picks or complete event
-        :type data:
-        :param typ: which event data to apply, 'pick' or 'event'
-        :type typ: str
-        :param authority_id: (currently unused)
-        :type: str
-        :raise OverwriteError:
-        """
-
-        def applyPicks(picks):
-            """
-            Creates ObsPy pick objects and append it to the picks list from the
-            PyLoT dictionary contain all picks.
-            :param picks:
-            :raise OverwriteError: raises an OverwriteError if the picks list is
-             not empty. The GUI will then ask for a decision.
-            """
-            # firstonset = find_firstonset(picks)
-            # check for automatic picks
-            print("Writing phases to ObsPy-quakeml file")
-            for key in picks:
-                if not picks[key].get('P'):
-                    continue
-                if picks[key]['P']['picker'] == 'auto':
-                    print("Existing auto-picks will be overwritten in pick-dictionary!")
-                    picks = picks_from_picksdict(picks)
-                    break
-                else:
-                    if self.get_evt_data().picks:
-                        raise OverwriteError('Existing picks would be overwritten!')
-                    else:
-                        picks = picks_from_picksdict(picks)
-                        break
-            self.get_evt_data().picks = picks
-            # if 'smi:local' in self.getID() and firstonset:
-            #     fonset_str = firstonset.strftime('%Y_%m_%d_%H_%M_%S')
-            #     ID = ResourceIdentifier('event/' + fonset_str)
-            #     ID.convertIDToQuakeMLURI(authority_id=authority_id)
-            #     self.get_evt_data().resource_id = ID
-
-        def applyEvent(event):
-            """
-            takes an `obspy.core.event.Event` object and applies all new
-            information on the event to the actual data
-            :param event:
-            """
-            if event is None:
-                print("applyEvent: Received None")
-                return
-            if self.isNew():
-                self.setEvtData(event)
-            else:
-                # prevent overwriting original pick information
-                event_old = self.get_evt_data()
-                if not event_old.resource_id == event.resource_id:
-                    print("WARNING: Missmatch in event resource id's: {} and {}".format(
-                        event_old.resource_id,
-                        event.resource_id))
-                else:
-                    picks = copy.deepcopy(event_old.picks)
-                    event = merge_picks(event, picks)
-                # apply event information from location
-                event_old.update(event)
-
-        applydata = {'pick': applyPicks,
-                     'event': applyEvent}
-
-        applydata[typ](data)
-        self._new = False
 
 
 class GenericDataStructure(object):
@@ -839,22 +248,6 @@ class PilotDataStructure(GenericDataStructure):
         self.setExpandFields(['root', 'database'])
 
 
-class ObspyDMTdataStructure(GenericDataStructure):
-    """
-    Object containing the data access information for the old PILOT data
-    structure.
-    """
-
-    def __init__(self, **fields):
-        if not fields:
-            fields = {'database': '',
-                      'root': ''}
-
-        GenericDataStructure.__init__(self, **fields)
-
-        self.setExpandFields(['root', 'database'])
-
-
 class SeiscompDataStructure(GenericDataStructure):
     """
     Dictionary containing the data access information for an SDS data archive:

pylot/core/io/event.py

@@ -0,0 +1,106 @@
+import copy
+from dataclasses import dataclass
+from typing import Union
+
+from obspy import read_events
+from obspy.core.event import Event as ObsPyEvent
+
+
+@dataclass
+class EventData:
+    evtdata: Union[ObsPyEvent, None] = None
+    _new: bool = False
+
+    def __init__(self, evtdata=None):
+        self.set_event_data(evtdata)
+
+    def set_event_data(self, evtdata):
+        if isinstance(evtdata, ObsPyEvent):
+            self.evtdata = evtdata
+        elif isinstance(evtdata, dict):
+            self.evtdata = self.read_pilot_event(**evtdata)
+        elif isinstance(evtdata, str):
+            self.evtdata = self.read_event_file(evtdata)
+        else:
+            self.set_new()
+            self.evtdata = ObsPyEvent(picks=[])
+
+    def read_event_file(self, evtdata: str) -> ObsPyEvent:
+        try:
+            cat = read_events(evtdata)
+            if len(cat) != 1:
+                raise ValueError(f'ambiguous event information for file: {evtdata}')
+            return cat[0]
+        except TypeError as e:
+            self.handle_event_file_error(e, evtdata)
+
+    def handle_event_file_error(self, e: TypeError, evtdata: str):
+        if 'Unknown format for file' in str(e):
+            if 'PHASES' in evtdata:
+                picks = self.picksdict_from_pilot(evtdata)
+                evtdata = ObsPyEvent(picks=self.picks_from_picksdict(picks))
+            elif 'LOC' in evtdata:
+                raise NotImplementedError('PILOT location information read support not yet implemented.')
+            elif 'event.pkl' in evtdata:
+                evtdata = self.qml_from_obspy_dmt(evtdata)
+            else:
+                raise e
+        else:
+            raise e
+
+    def set_new(self):
+        self._new = True
+
+    def is_new(self) -> bool:
+        return self._new
+
+    def get_picks_str(self) -> str:
+        return '\n'.join(str(pick) for pick in self.evtdata.picks)
+
+    def replace_origin(self, event: ObsPyEvent, force_overwrite: bool = False):
+        if self.evtdata.origins or force_overwrite:
+            event.origins = self.evtdata.origins
+
+    def replace_magnitude(self, event: ObsPyEvent, force_overwrite: bool = False):
+        if self.evtdata.magnitudes or force_overwrite:
+            event.magnitudes = self.evtdata.magnitudes
+
+    def replace_picks(self, event: ObsPyEvent, picktype: str):
+        checkflag = 1
+        picks = event.picks
+        for j, pick in reversed(list(enumerate(picks))):
+            if picktype in str(pick.method_id.id):
+                picks.pop(j)
+                checkflag = 2
+
+        if checkflag > 0:
+            for pick in self.evtdata.picks:
+                if picktype in str(pick.method_id.id):
+                    picks.append(pick)
+
+    def get_id(self) -> Union[str, None]:
+        try:
+            return self.evtdata.resource_id.id
+        except:
+            return None
+
+    def apply_event_data(self, data, typ='pick'):
+        if typ == 'pick':
+            self.apply_picks(data)
+        elif typ == 'event':
+            self.apply_event(data)
+
+    def apply_picks(self, picks):
+        self.evtdata.picks = picks
+
+    def apply_event(self, event: ObsPyEvent):
+        if self.is_new():
+            self.evtdata = event
+        else:
+            old_event = self.evtdata
+            if old_event.resource_id == event.resource_id:
+                picks = copy.deepcopy(old_event.picks)
+                event = self.merge_picks(event, picks)
+                old_event.update(event)
+            else:
+                print(f"WARNING: Mismatch in event resource id's: {old_event.resource_id} and {event.resource_id}")

pylot/core/io/phases.py

@@ -21,25 +21,6 @@ from pylot.core.util.utils import get_owner, full_range, four_digits, transformF
     backtransformFilterString, loopIdentifyPhase, identifyPhase
 
 
-def add_amplitudes(event, amplitudes):
-    amplitude_list = []
-    for pick in event.picks:
-        try:
-            a0 = amplitudes[pick.waveform_id.station_code]
-            amplitude = ope.Amplitude(generic_amplitude=a0 * 1e-3)
-            amplitude.unit = 'm'
-            amplitude.category = 'point'
-            amplitude.waveform_id = pick.waveform_id
-            amplitude.magnitude_hint = 'ML'
-            amplitude.pick_id = pick.resource_id
-            amplitude.type = 'AML'
-            amplitude_list.append(amplitude)
-        except KeyError:
-            continue
-    event.amplitudes = amplitude_list
-    return event
-
-
 def readPILOTEvent(phasfn=None, locfn=None, authority_id='RUB', **kwargs):
     """
     readPILOTEvent - function
@@ -193,31 +174,6 @@ def convert_pilot_times(time_array):
     return UTCDateTime(*times)
 
 
-def picksdict_from_obs(fn):
-    """
-    create pick dictionary from obs file
-    :param fn: filename
-    :type fn:
-    :return:
-    :rtype:
-    """
-    picks = dict()
-    station_name = str()
-    for line in open(fn, 'r'):
-        if line.startswith('#'):
-            continue
-        else:
-            phase_line = line.split()
-            if not station_name == phase_line[0]:
-                phase = dict()
-            station_name = phase_line[0]
-            phase_name = phase_line[4].upper()
-            pick = UTCDateTime(phase_line[6] + phase_line[7] + phase_line[8])
-            phase[phase_name] = dict(mpp=pick, fm=phase_line[5])
-            picks[station_name] = phase
-    return picks
-
-
 def picksdict_from_picks(evt, parameter=None):
     """
     Takes an Event object and return the pick dictionary commonly used within
@@ -373,636 +329,228 @@ def picks_from_picksdict(picks, creation_info=None):
     return picks_list
 
 
-def reassess_pilot_db(root_dir, db_dir, out_dir=None, fn_param=None, verbosity=0):
+def write_phases(arrivals, fformat, filename, parameter=None, eventinfo=None):
-    # TODO: change root to datapath
-    db_root = os.path.join(root_dir, db_dir)
-    evt_list = glob.glob1(db_root, 'e????.???.??')
-
-    for evt in evt_list:
-        if verbosity > 0:
-            print('Reassessing event {0}'.format(evt))
-        reassess_pilot_event(root_dir, db_dir, evt, out_dir, fn_param, verbosity)
-
-
-def reassess_pilot_event(root_dir, db_dir, event_id, out_dir=None, fn_param=None, verbosity=0):
-    from obspy import read
-
-    from pylot.core.io.inputs import PylotParameter
-    from pylot.core.pick.utils import earllatepicker
-    # TODO: change root to datapath
-
-    default = PylotParameter(fn_param, verbosity)
-
-    search_base = os.path.join(root_dir, db_dir, event_id)
-    phases_file = glob.glob(os.path.join(search_base, 'PHASES.mat'))
-    if not phases_file:
-        return
-    if verbosity > 1:
-        print('Opening PILOT phases file: {fn}'.format(fn=phases_file[0]))
-    picks_dict = picksdict_from_pilot(phases_file[0])
-    if verbosity > 0:
-        print('Dictionary read from PHASES.mat:\n{0}'.format(picks_dict))
-    datacheck = list()
-    info = None
-    for station in picks_dict.keys():
-        fn_pattern = os.path.join(search_base, '{0}*'.format(station))
-        try:
-            st = read(fn_pattern)
-        except TypeError as e:
-            if 'Unknown format for file' in e.message:
-                try:
-                    st = read(fn_pattern, format='GSE2')
-                except ValueError as e:
-                    if e.message == 'second must be in 0..59':
-                        info = 'A known Error was raised. Please find the list of corrupted files and double-check these files.'
-                        datacheck.append(fn_pattern + ' (time info)\n')
-                        continue
-                    else:
-                        raise ValueError(e.message)
-                except Exception as e:
-                    if 'No file matching file pattern:' in e.message:
-                        if verbosity > 0:
-                            warnings.warn('no waveform data found for station {station}'.format(station=station),
-                                          RuntimeWarning)
-                        datacheck.append(fn_pattern + ' (no data)\n')
-                        continue
-                    else:
-                        raise e
-            else:
-                raise e
-        for phase in picks_dict[station].keys():
-            try:
-                mpp = picks_dict[station][phase]['mpp']
-            except KeyError as e:
-                print(e.message, station)
-                continue
-            sel_st = select_for_phase(st, phase)
-            if not sel_st:
-                msg = 'no waveform data found for station {station}'.format(station=station)
-                warnings.warn(msg, RuntimeWarning)
-                continue
-            stime, etime = full_range(sel_st)
-            rel_pick = mpp - stime
-            epp, lpp, spe = earllatepicker(sel_st,
-                                           default.get('nfac{0}'.format(phase)),
-                                           default.get('tsnrz' if phase == 'P' else 'tsnrh'),
-                                           Pick1=rel_pick,
-                                           iplot=0,
-                                           verbosity=0)
-            if epp is None or lpp is None:
-                continue
-            epp = stime + epp
-            lpp = stime + lpp
-            min_diff = 3 * st[0].stats.delta
-            if lpp - mpp < min_diff:
-                lpp = mpp + min_diff
-            if mpp - epp < min_diff:
-                epp = mpp - min_diff
-            picks_dict[station][phase] = dict(epp=epp, mpp=mpp, lpp=lpp, spe=spe)
-    if datacheck:
-        if info:
-            if verbosity > 0:
-                print(info + ': {0}'.format(search_base))
-        fncheck = open(os.path.join(search_base, 'datacheck_list'), 'w')
-        fncheck.writelines(datacheck)
-        fncheck.close()
-        del datacheck
-    # create Event object for export
-    evt = ope.Event(resource_id=event_id)
-    evt.picks = picks_from_picksdict(picks_dict)
-    # write phase information to file
-    if not out_dir:
-        fnout_prefix = os.path.join(root_dir, db_dir, event_id, 'PyLoT_{0}.'.format(event_id))
-    else:
-        out_dir = os.path.join(out_dir, db_dir)
-        if not os.path.isdir(out_dir):
-            os.makedirs(out_dir)
-        fnout_prefix = os.path.join(out_dir, 'PyLoT_{0}.'.format(event_id))
-    evt.write(fnout_prefix + 'xml', format='QUAKEML')
-
-
-def writephases(arrivals, fformat, filename, parameter=None, eventinfo=None):
     """
-    Function of methods to write phases to the following standard file
+    Writes earthquake phase data to different file formats.
-    formats used for locating earthquakes:
 
-    HYPO71, NLLoc, VELEST, HYPOSAT, FOCMEC, and hypoDD
+    :param arrivals: Dictionary containing phase information (station ID, phase, first motion, weight, etc.)
-
-    :param arrivals:dictionary containing all phase information including
-     station ID, phase, first motion, weight (uncertainty), ...
     :type arrivals: dict
-
+    :param fformat: File format to write to (e.g., 'NLLoc', 'HYPO71', 'HYPOSAT', 'VELEST', 'HYPODD', 'FOCMEC')
-    :param fformat: chosen file format (location routine),
-    choose between NLLoc, HYPO71, HYPOSAT, VELEST,
-    HYPOINVERSE, FOCMEC, and hypoDD
     :type fformat: str
-
+    :param filename: Path and name of the output phase file
-    :param filename: full path and name of phase file
+    :type filename: str
-    :type filename:  string
+    :param parameter: Additional parameters for writing the phase data
-
+    :type parameter: object
-    :param parameter: all input information
+    :param eventinfo: Event information needed for specific formats like VELEST, FOCMEC, and HASH
-    :type parameter:  object
+    :type eventinfo: obspy.core.event.Event
-
-    :param eventinfo: optional, needed for VELEST-cnv file
-            and FOCMEC- and HASH-input files 
-    :type eventinfo: `obspy.core.event.Event` object
     """
-    if fformat == 'NLLoc':
-        print("Writing phases to %s for NLLoc" % filename)
-        fid = open("%s" % filename, 'w')
-        # write header
-        fid.write('# EQEVENT: %s Label: EQ%s  Loc:  X 0.00  Y 0.00  Z 10.00  OT 0.00 \n' %
-                  (parameter.get('database'), parameter.get('eventID')))
-        arrivals = chooseArrivals(arrivals)  # MP MP what is chooseArrivals? It is not defined anywhere
-        for key in arrivals:
-            # P onsets
-            if 'P' in arrivals[key]:
-                try:
-                    fm = arrivals[key]['P']['fm']
-                except KeyError as e:
-                    print(e)
-                    fm = None
-                if fm is None:
-                    fm = '?'
-                onset = arrivals[key]['P']['mpp']
-                year = onset.year
-                month = onset.month
-                day = onset.day
-                hh = onset.hour
-                mm = onset.minute
-                ss = onset.second
-                ms = onset.microsecond
-                ss_ms = ss + ms / 1000000.0
-                pweight = 1  # use pick
-                try:
-                    if arrivals[key]['P']['weight'] >= 4:
-                        pweight = 0  # do not use pick
-                        print("Station {}: Uncertain pick, do not use it!".format(key))
-                except KeyError as e:
-                    print(e.message + '; no weight set during processing')
-                fid.write('%s ? ? ? P   %s %d%02d%02d %02d%02d %7.4f GAU 0 0 0 0 %d \n' % (key,
-                                                                                           fm,
-                                                                                           year,
-                                                                                           month,
-                                                                                           day,
-                                                                                           hh,
-                                                                                           mm,
-                                                                                           ss_ms,
-                                                                                           pweight))
-            # S onsets
-            if 'S' in arrivals[key] and arrivals[key]['S']['mpp'] is not None:
-                fm = '?'
-                onset = arrivals[key]['S']['mpp']
-                year = onset.year
-                month = onset.month
-                day = onset.day
-                hh = onset.hour
-                mm = onset.minute
-                ss = onset.second
-                ms = onset.microsecond
-                ss_ms = ss + ms / 1000000.0
-                sweight = 1  # use pick
-                try:
-                    if arrivals[key]['S']['weight'] >= 4:
-                        sweight = 0  # do not use pick
-                except KeyError as e:
-                    print(str(e) + '; no weight set during processing')
-                Ao = arrivals[key]['S']['Ao']  # peak-to-peak amplitude
-                if Ao == None:
-                    Ao = 0.0
-                # fid.write('%s ? ? ? S   %s %d%02d%02d %02d%02d %7.4f GAU 0 0 0 0 %d \n' % (key,
-                fid.write('%s ? ? ? S   %s %d%02d%02d %02d%02d %7.4f GAU 0 %9.2f 0 0 %d \n' % (key,
-                                                                                               fm,
-                                                                                               year,
-                                                                                               month,
-                                                                                               day,
-                                                                                               hh,
-                                                                                               mm,
-                                                                                               ss_ms,
-                                                                                               Ao,
-                                                                                               sweight))
 
-        fid.close()
+    def write_nlloc():
-    elif fformat == 'HYPO71':
+        with open(filename, 'w') as fid:
-        print("Writing phases to %s for HYPO71" % filename)
+            fid.write('# EQEVENT: {} Label: EQ{}  Loc:  X 0.00  Y 0.00  Z 10.00  OT 0.00 \n'.format(
-        fid = open("%s" % filename, 'w')
+                parameter.get('database'), parameter.get('eventID')))
-        # write header
+            for key, value in arrivals.items():
-        fid.write('                                                                %s\n' %
+                for phase in ['P', 'S']:
-                  parameter.get('eventID'))
+                    if phase in value:
-        arrivals = chooseArrivals(arrivals)  # MP MP what is chooseArrivals? It is not defined anywhere
+                        fm = value[phase].get('fm', '?')
-        for key in arrivals:
+                        onset = value[phase]['mpp']
-            if arrivals[key]['P']['weight'] < 4:
+                        ss_ms = onset.second + onset.microsecond / 1000000.0
-                stat = key
+                        weight = 1 if value[phase].get('weight', 0) < 4 else 0
-                if len(stat) > 4:  # HYPO71 handles only 4-string station IDs
+                        amp = value[phase].get('Ao', 0.0) if phase == 'S' else ''
-                    stat = stat[1:5]
+                        fid.write('{} ? ? ? {}   {}{}{} {}{} {:7.4f} GAU 0 {} 0 0 {}\n'.format(
-                Ponset = arrivals[key]['P']['mpp']
+                            key, phase, fm, onset.year, onset.month, onset.day, onset.hour, onset.minute, ss_ms, amp,
-                Sonset = arrivals[key]['S']['mpp']
+                            weight))
-                pweight = arrivals[key]['P']['weight']
-                sweight = arrivals[key]['S']['weight']
-                fm = arrivals[key]['P']['fm']
-                if fm is None:
-                    fm = '-'
-                Ao = arrivals[key]['S']['Ao']
-                if Ao is None:
-                    Ao = ''
-                else:
-                    Ao = str('%7.2f' % Ao)
-                year = Ponset.year
-                if year >= 2000:
-                    year = year - 2000
-                else:
-                    year = year - 1900
-                month = Ponset.month
-                day = Ponset.day
-                hh = Ponset.hour
-                mm = Ponset.minute
-                ss = Ponset.second
-                ms = Ponset.microsecond
-                ss_ms = ss + ms / 1000000.0
-                if pweight < 2:
-                    pstr = 'I'
-                elif pweight >= 2:
-                    pstr = 'E'
-                if arrivals[key]['S']['weight'] < 4:
-                    Sss = Sonset.second
-                    Sms = Sonset.microsecond
-                    Sss_ms = Sss + Sms / 1000000.0
-                    Sss_ms = str('%5.02f' % Sss_ms)
-                    if sweight < 2:
-                        sstr = 'I'
-                    elif sweight >= 2:
-                        sstr = 'E'
-                    fid.write('%-4s%sP%s%d %02d%02d%02d%02d%02d%5.2f       %s%sS %d   %s\n' % (stat,
-                                                                                               pstr,
-                                                                                               fm,
-                                                                                               pweight,
-                                                                                               year,
-                                                                                               month,
-                                                                                               day,
-                                                                                               hh,
-                                                                                               mm,
-                                                                                               ss_ms,
-                                                                                               Sss_ms,
-                                                                                               sstr,
-                                                                                               sweight,
-                                                                                               Ao))
-                else:
-                    fid.write('%-4s%sP%s%d %02d%02d%02d%02d%02d%5.2f                  %s\n' % (stat,
-                                                                                               pstr,
-                                                                                               fm,
-                                                                                               pweight,
-                                                                                               year,
-                                                                                               month,
-                                                                                               day,
-                                                                                               hh,
-                                                                                               mm,
-                                                                                               ss_ms,
-                                                                                               Ao))
 
-        fid.close()
+    def write_hypo71():
+        with open(filename, 'w') as fid:
+            fid.write(
+                '                                                                {}\n'.format(parameter.get('eventID')))
+            for key, value in arrivals.items():
+                if value['P'].get('weight', 0) < 4:
+                    stat = key[:4]
+                    Ponset = value['P']['mpp']
+                    Sonset = value.get('S', {}).get('mpp')
+                    pweight = value['P'].get('weight', 0)
+                    sweight = value.get('S', {}).get('weight', 0)
+                    fm = value['P'].get('fm', '-')
+                    Ao = value.get('S', {}).get('Ao', '')
+                    year = Ponset.year - 2000 if Ponset.year >= 2000 else Ponset.year - 1900
+                    ss_ms = Ponset.second + Ponset.microsecond / 1000000.0
+                    if Sonset:
+                        Sss_ms = Sonset.second + Sonset.microsecond / 1000000.0
+                        fid.write('{}P{}{}{} {}{}{}{}{} {:5.2f}       {}{}S {}   {}\n'.format(
+                            stat, 'I' if pweight < 2 else 'E', fm, pweight, year, Ponset.month, Ponset.day,
+                            Ponset.hour, Ponset.minute, ss_ms, Sss_ms, 'I' if sweight < 2 else 'E', sweight, Ao))
+                    else:
+                        fid.write('{}P{}{}{} {}{}{}{}{} {:5.2f}                  {}\n'.format(
+                            stat, 'I' if pweight < 2 else 'E', fm, pweight, year, Ponset.month, Ponset.day,
+                            Ponset.hour, Ponset.minute, ss_ms, Ao))
 
-    elif fformat == 'HYPOSAT':
+    def write_hyposat():
-        print("Writing phases to %s for HYPOSAT" % filename)
+        with open(filename, 'w') as fid:
-        fid = open("%s" % filename, 'w')
+            fid.write('{}, event {} \n'.format(parameter.get('database'), parameter.get('eventID')))
-        # write header
+            for key, value in arrivals.items():
-        fid.write('%s, event %s \n' % (parameter.get('database'), parameter.get('eventID')))
+                for phase in ['P', 'S']:
-        arrivals = chooseArrivals(arrivals)  # MP MP what is chooseArrivals? It is not defined anywhere
+                    if phase in value and value[phase].get('weight', 0) < 4:
-        for key in arrivals:
+                        onset = value[phase]['mpp']
-            # P onsets
+                        ss_ms = onset.second + onset.microsecond / 1000000.0
-            if 'P' in  arrivals[key] and arrivals[key]['P']['mpp'] is not None:
+                        std = value[phase].get('spe', parameter.get('timeerrorsP')[value[phase].get('weight', 0)])
-                if arrivals[key]['P']['weight'] < 4:
+                        fid.write(
-                    Ponset = arrivals[key]['P']['mpp']
+                            '{:<5} {}1       {:4} {:02} {:02} {:02} {:02} {:05.02f}   {:5.3f} -999.   0.00 -999.  0.00\n'.format(
-                    pyear = Ponset.year
+                                key, phase, onset.year, onset.month, onset.day, onset.hour, onset.minute, ss_ms, std))
-                    pmonth = Ponset.month
-                    pday = Ponset.day
-                    phh = Ponset.hour
-                    pmm = Ponset.minute
-                    pss = Ponset.second
-                    pms = Ponset.microsecond
-                    Pss = pss + pms / 1000000.0
-                    # use symmetrized picking error as std
-                    # (read the HYPOSAT manual)
-                    pstd = arrivals[key]['P']['spe']
-                    if pstd is None:
-                        errorsP = parameter.get('timeerrorsP')
-                        if arrivals[key]['P']['weight'] == 0:
-                            pstd = errorsP[0]
-                        elif arrivals[key]['P']['weight'] == 1:
-                            pstd = errorsP[1]
-                        elif arrivals[key]['P']['weight'] == 2:
-                            pstd = errorsP[2]
-                        elif arrivals[key]['P']['weight'] == 3:
-                            psrd = errorsP[3]
-                        else:
-                            pstd = errorsP[4]
-                    fid.write('%-5s P1       %4.0f %02d %02d %02d %02d %05.02f   %5.3f -999.   0.00 -999.  0.00\n'
-                              % (key, pyear, pmonth, pday, phh, pmm, Pss, pstd))
-            # S onsets
-            if 'S' in arrivals[key] and arrivals[key]['S']['mpp'] is not None:
-                if arrivals[key]['S']['weight'] < 4:
-                    Sonset = arrivals[key]['S']['mpp']
-                    syear = Sonset.year
-                    smonth = Sonset.month
-                    sday = Sonset.day
-                    shh = Sonset.hour
-                    smm = Sonset.minute
-                    sss = Sonset.second
-                    sms = Sonset.microsecond
-                    Sss = sss + sms / 1000000.0
-                    sstd = arrivals[key]['S']['spe']
-                    if pstd is None:
-                        errorsS = parameter.get('timeerrorsS')
-                        if arrivals[key]['S']['weight'] == 0:
-                            pstd = errorsS[0]
-                        elif arrivals[key]['S']['weight'] == 1:
-                            pstd = errorsS[1]
-                        elif arrivals[key]['S']['weight'] == 2:
-                            pstd = errorsS[2]
-                        elif arrivals[key]['S']['weight'] == 3:
-                            psrd = errorsS[3]
-                        else:
-                            pstd = errorsP[4]
-                    fid.write('%-5s S1       %4.0f %02d %02d %02d %02d %05.02f   %5.3f -999.   0.00 -999.  0.00\n'
-                              % (key, syear, smonth, sday, shh, smm, Sss, sstd))
-        fid.close()
 
-    elif fformat == 'VELEST':
+    def write_velest():
-        print("Writing phases to %s for VELEST" % filename)
+        if not eventinfo:
-        fid = open("%s" % filename, 'w')
-        # get informations needed in cnv-file
-        # check, whether latitude is N or S and longitude is E or W
-        try:
-            eventsource = eventinfo.origins[0]
-        except:
             print("No source origin calculated yet, thus no cnv-file creation possible!")
             return
-        if eventsource['latitude'] < 0:
+        with open(filename, 'w') as fid:
-            cns = 'S'
+            origin = eventinfo.origins[0]
-        else:
+            lat_dir = 'S' if origin.latitude < 0 else 'N'
-            cns = 'N'
+            lon_dir = 'W' if origin.longitude < 0 else 'E'
-        if eventsource['longitude'] < 0:
+            year = origin.time.year - 2000 if origin.time.year >= 2000 else origin.time.year - 1900
-            cew = 'W'
+            fid.write(
-        else:
+                '{}{}{} {}{} {} {:05.2f} {:7.4f}{} {:8.4f}{} {:7.2f} {:6.2f}     {:02.0f}  0.0 0.03  1.0  1.0\n'.format(
-            cew = 'E'
+                    year, origin.time.month, origin.time.day, origin.time.hour, origin.time.minute, origin.time.second,
-        # get last two integers of origin year
+                    origin.latitude, lat_dir, origin.longitude, lon_dir, origin.depth, eventinfo.magnitudes[0].mag, 0))
-        stime = eventsource['time']
+            for key, value in arrivals.items():
-        if stime.year - 2000 >= 0:
+                for phase in ['P', 'S']:
-            syear = stime.year - 2000
+                    if phase in value and value[phase].get('weight', 0) < 4:
-        else:
+                        onset = value[phase]['mpp']
-            syear = stime.year - 1900
+                        rt = (onset - origin.time).total_seconds()
-        ifx = 0  # default value, see VELEST manual, pp. 22-23
+                        fid.write('{:<4}{}{}{:6.2f}\n'.format(key[:4], phase, value[phase].get('weight', 0), rt))
-        # write header
-        fid.write('%s%02d%02d %02d%02d %05.2f %7.4f%c %8.4f%c %7.2f %6.2f     %02.0f  0.0 0.03  1.0  1.0\n' % (
-            syear, stime.month, stime.day, stime.hour, stime.minute, stime.second, eventsource['latitude'],
-            cns, eventsource['longitude'], cew, eventsource['depth'], eventinfo.magnitudes[0]['mag'], ifx))
-        n = 0
-        # check whether arrivals are dictionaries (autoPyLoT) or pick object (PyLoT)
-        if isinstance(arrivals, dict) == False:
-            # convert pick object (PyLoT) into dictionary
-            evt = ope.Event(resource_id=eventinfo['resource_id'])
-            evt.picks = arrivals
-            arrivals = picksdict_from_picks(evt)
-        # check for automatic and manual picks
-        # prefer manual picks
-        usedarrivals = chooseArrivals(arrivals)
-        for key in usedarrivals:
-            # P onsets
-            if 'P' in usedarrivals[key]:
-                if usedarrivals[key]['P']['weight'] < 4:
-                    n += 1
-                    stat = key
-                    if len(stat) > 4:  # VELEST handles only 4-string station IDs
-                        stat = stat[1:5]
-                    Ponset = usedarrivals[key]['P']['mpp']
-                    Pweight = usedarrivals[key]['P']['weight']
-                    Prt = Ponset - stime  # onset time relative to source time
-                    if n % 6 != 0:
-                        fid.write('%-4sP%d%6.2f' % (stat, Pweight, Prt))
-                    else:
-                        fid.write('%-4sP%d%6.2f\n' % (stat, Pweight, Prt))
-                        # S onsets
-            if 'S' in usedarrivals[key]:
-                if usedarrivals[key]['S']['weight'] < 4:
-                    n += 1
-                    stat = key
-                    if len(stat) > 4:  # VELEST handles only 4-string station IDs
-                        stat = stat[1:5]
-                    Sonset = usedarrivals[key]['S']['mpp']
-                    Sweight = usedarrivals[key]['S']['weight']
-                    Srt = Ponset - stime  # onset time relative to source time
-                    if n % 6 != 0:
-                        fid.write('%-4sS%d%6.2f' % (stat, Sweight, Srt))
-                    else:
-                        fid.write('%-4sS%d%6.2f\n' % (stat, Sweight, Srt))
-        fid.close()
 
-    elif fformat == 'HYPODD':
+    def write_hypodd():
-        print("Writing phases to %s for hypoDD" % filename)
+        if not eventinfo:
-        fid = open("%s" % filename, 'w')
-        # get event information needed for hypoDD-phase file
-        try:
-            eventsource = eventinfo.origins[0]
-        except:
             print("No source origin calculated yet, thus no hypoDD-infile creation possible!")
             return
-        stime = eventsource['time']
+        with open(filename, 'w') as fid:
-        try:
+            origin = eventinfo.origins[0]
-            event = eventinfo['pylot_id']
+            stime = origin.time
-            hddID = event.split('.')[0][1:5]
+            fid.write('# {}  {} {} {} {} {} {:7.4f} +{:6.4f} {:7.4f} {:4.2f} 0.1 0.5 {:4.2f}      {}\n'.format(
-        except:
+                stime.year, stime.month, stime.day, stime.hour, stime.minute, stime.second,
-            print("Error 1111111!")
+                origin.latitude, origin.longitude, origin.depth / 1000, eventinfo.magnitudes[0].mag,
-            hddID = "00000"
+                origin.quality.standard_error, "00000"))
-            # write header
+            for key, value in arrivals.items():
-        fid.write('# %d  %d %d %d %d %5.2f %7.4f +%6.4f %7.4f %4.2f 0.1 0.5 %4.2f      %s\n' % (
+                for phase in ['P', 'S']:
-            stime.year, stime.month, stime.day, stime.hour, stime.minute, stime.second,
+                    if phase in value and value[phase].get('weight', 0) < 4:
-            eventsource['latitude'], eventsource['longitude'], eventsource['depth'] / 1000,
+                        onset = value[phase]['mpp']
-            eventinfo.magnitudes[0]['mag'], eventsource['quality']['standard_error'], hddID))
+                        rt = (onset - stime).total_seconds()
-        # check whether arrivals are dictionaries (autoPyLoT) or pick object (PyLoT)
+                        fid.write('{}    {:6.3f}  1  {}\n'.format(key, rt, phase))
-        if isinstance(arrivals, dict) == False:
-            # convert pick object (PyLoT) into dictionary
-            evt = ope.Event(resource_id=eventinfo['resource_id'])
-            evt.picks = arrivals
-            arrivals = picksdict_from_picks(evt)
-        # check for automatic and manual picks
-        # prefer manual picks
-        usedarrivals = chooseArrivals(arrivals)
-        for key in usedarrivals:
-            if 'P' in usedarrivals[key]:
-                # P onsets
-                if usedarrivals[key]['P']['weight'] < 4:
-                    Ponset = usedarrivals[key]['P']['mpp']
-                    Prt = Ponset - stime  # onset time relative to source time
-                    fid.write('%s    %6.3f  1  P\n' % (key, Prt))
-            if 'S' in usedarrivals[key]:
-                # S onsets
-                if usedarrivals[key]['S']['weight'] < 4:
-                    Sonset = usedarrivals[key]['S']['mpp']
-                    Srt = Sonset - stime  # onset time relative to source time
-                    fid.write('%-5s    %6.3f  1  S\n' % (key, Srt))
 
-        fid.close()
+    def write_focmec():
-
+        if not eventinfo:
-    elif fformat == 'FOCMEC':
-        print("Writing phases to %s for FOCMEC" % filename)
-        fid = open("%s" % filename, 'w')
-        # get event information needed for FOCMEC-input file
-        try:
-            eventsource = eventinfo.origins[0]
-        except:
             print("No source origin calculated yet, thus no FOCMEC-infile creation possible!")
             return
-        stime = eventsource['time']
+        with open(filename, 'w') as fid:
-
+            origin = eventinfo.origins[0]
-        # avoid printing '*' in focmec-input file
+            stime = origin.time
-        if parameter.get('eventid') == '*' or parameter.get('eventid') is None:
+            fid.write('{} {}{:02d}{:02d}{:02d}{:02d}{:02.0f} {:7.4f} {:6.4f} {:3.1f} {:3.1f}\n'.format(
-            evID = 'e0000'
+                parameter.get('eventid', 'e0000'), stime.year, stime.month, stime.day, stime.hour, stime.minute,
-        else:
+                stime.second, origin.latitude, origin.longitude, origin.depth / 1000, eventinfo.magnitudes[0].mag))
-            evID = parameter.get('eventid')
+            for key, value in arrivals.items():
-
+                if 'P' in value and value['P'].get('weight', 0) < 4 and value['P'].get('fm'):
-        # write header line including event information
+                    for pick in eventinfo.picks:
-        fid.write('%s %d%02d%02d%02d%02d%02.0f %7.4f %6.4f %3.1f %3.1f\n' % (evID,
+                        if pick.waveform_id.station_code == key:
-                                                                             stime.year, stime.month, stime.day,
+                            for arrival in origin.arrivals:
-                                                                             stime.hour, stime.minute, stime.second,
+                                if arrival.pick_id == pick.resource_id and arrival.phase == 'P':
-                                                                             eventsource['latitude'],
+                                    stat = key[:4]
-                                                                             eventsource['longitude'],
+                                    az = arrival.azimuth
-                                                                             eventsource['depth'] / 1000,
+                                    inz = arrival.takeoff_angle
-                                                                             eventinfo.magnitudes[0]['mag']))
+                                    fid.write('{:<4}  {:6.2f}  {:6.2f}{}\n'.format(stat, az, inz, value['P']['fm']))
-        picks = eventinfo.picks
-        # check whether arrivals are dictionaries (autoPyLoT) or pick object (PyLoT)
-        if isinstance(arrivals, dict) == False:
-            # convert pick object (PyLoT) into dictionary
-            evt = ope.Event(resource_id=eventinfo['resource_id'])
-            evt.picks = arrivals
-            arrivals = picksdict_from_picks(evt)
-        # check for automatic and manual picks
-        # prefer manual picks
-        usedarrivals = chooseArrivals(arrivals)
-        for key in usedarrivals:
-            if 'P' in usedarrivals[key]:
-                if usedarrivals[key]['P']['weight'] < 4 and usedarrivals[key]['P']['fm'] is not None:
-                    stat = key
-                    for i in range(len(picks)):
-                        station = picks[i].waveform_id.station_code
-                        if station == stat:
-                            # get resource ID
-                            resid_picks = picks[i].get('resource_id')
-                            # find same ID in eventinfo
-                            # there it is the pick_id!!
-                            for j in range(len(eventinfo.origins[0].arrivals)):
-                                resid_eventinfo = eventinfo.origins[0].arrivals[j].get('pick_id')
-                                if resid_eventinfo == resid_picks and eventinfo.origins[0].arrivals[j].phase == 'P':
-                                    if len(stat) > 4:  # FOCMEC handles only 4-string station IDs
-                                        stat = stat[1:5]
-                                    az = eventinfo.origins[0].arrivals[j].get('azimuth')
-                                    inz = eventinfo.origins[0].arrivals[j].get('takeoff_angle')
-                                    fid.write('%-4s  %6.2f  %6.2f%s \n' % (stat,
-                                                                           az,
-                                                                           inz,
-                                                                           usedarrivals[key]['P']['fm']))
                                     break
 
-        fid.close()
+    def write_hash():
+        # Define filenames for HASH driver 1 and 2
+        filename1 = f"{filename}drv1.phase"
+        filename2 = f"{filename}drv2.phase"
 
+        print(f"Writing phases to {filename1} for HASH-driver 1")
+        print(f"Writing phases to {filename2} for HASH-driver 2")
+
+        # Open files for writing
+        with open(filename1, 'w') as fid1, open(filename2, 'w') as fid2:
+            # Get event information needed for HASH-input file
+            try:
+                eventsource = eventinfo.origins[0]
+            except IndexError:
+                print("No source origin calculated yet, thus no cnv-file creation possible!")
+                return
+
+            event = parameter.get('eventID')
+            hashID = event.split('.')[0][1:5]
+            latdeg = eventsource['latitude']
+            latmin = (eventsource['latitude'] * 60) / 10000
+            londeg = eventsource['longitude']
+            lonmin = (eventsource['longitude'] * 60) / 10000
+
+            erh = (eventsource.origin_uncertainty['min_horizontal_uncertainty'] +
+                   eventsource.origin_uncertainty['max_horizontal_uncertainty']) / 2000
+            erz = eventsource.depth_errors['uncertainty']
+
+            stime = eventsource['time']
+            syear = stime.year % 100  # Calculate two-digit year
+
+            picks = eventinfo.picks
+
+            # Write header line including event information for HASH-driver 1
+            fid1.write(f"{syear:02d}{stime.month:02d}{stime.day:02d}{stime.hour:02d}{stime.minute:02d}"
+                       f"{stime.second:05.2f}{latdeg:2d}N{latmin:05.2f}{londeg:3d}E{lonmin:05.2f}"
+                       f"{eventsource['depth']:6.2f}{eventinfo.magnitudes[0]['mag']:4.2f}{erh:5.2f}{erz:5.2f}{hashID}\n")
+
+            # Write header line including event information for HASH-driver 2
+            fid2.write(f"{syear:02d}{stime.month:02d}{stime.day:02d}{stime.hour:02d}{stime.minute:02d}"
+                       f"{stime.second:05.2f}{latdeg}N{latmin:05.2f}{londeg}E{lonmin:6.2f}{eventsource['depth']:5.2f}"
+                       f"{eventsource['quality']['used_phase_count']:3d}{erh:5.2f}{erz:5.2f}"
+                       f"{eventinfo.magnitudes[0]['mag']:4.2f}{hashID}\n")
+
+            # Write phase lines
+            for key, arrival in arrivals.items():
+                if 'P' in arrival and arrival['P']['weight'] < 4 and arrival['P']['fm'] is not None:
+                    stat = key
+                    ccode = arrival['P']['channel']
+                    ncode = arrival['P']['network']
+                    Pqual = 'I' if arrival['P']['weight'] < 2 else 'E'
+
+                    for pick in picks:
+                        if pick.waveform_id.station_code == stat:
+                            resid_picks = pick.get('resource_id')
+                            for origin_arrival in eventinfo.origins[0].arrivals:
+                                if (origin_arrival.get('pick_id') == resid_picks and
+                                        origin_arrival.phase == 'P'):
+                                    if len(stat) > 4:  # HASH handles only 4-character station IDs
+                                        stat = stat[1:5]
+
+                                    az = origin_arrival.get('azimuth')
+                                    inz = origin_arrival.get('takeoff_angle')
+                                    dist = origin_arrival.get('distance')
+
+                                    # Write phase line for HASH-driver 1
+                                    fid1.write(f"{stat:<4}{Pqual}P{arrival['P']['fm']}{arrival['P']['weight']:d}"
+                                               f"{dist:3.1f}{inz:03d}{az:03d}{ccode}\n")
+
+                                    # Write phase line for HASH-driver 2
+                                    fid2.write(f"{stat:<4} {ncode} {ccode} {Pqual} {arrival['P']['fm']}\n")
+                                    break
+
+            fid1.write(f"{'':<36}{hashID}")
+
+    # Prefer Manual Picks over automatic ones if possible
+    arrivals = chooseArrivals(arrivals)  # Function not defined, assumed to exist
+
+    if fformat == 'NLLoc':
+        write_nlloc()
+    elif fformat == 'HYPO71':
+        write_hypo71()
+    elif fformat == 'HYPOSAT':
+        write_hyposat()
+    elif fformat == 'VELEST':
+        write_velest()
+    elif fformat == 'HYPODD':
+        write_hypodd()
+    elif fformat == 'FOCMEC':
+        write_focmec()
     elif fformat == 'HASH':
-        # two different input files for 
+        write_hash()
-        # HASH-driver 1 and 2 (see HASH manual!)
-        filename1 = filename + 'drv1' + '.phase'
-        filename2 = filename + 'drv2' + '.phase'
-        print("Writing phases to %s for HASH for HASH-driver 1" % filename1)
-        fid1 = open("%s" % filename1, 'w')
-        print("Writing phases to %s for HASH for HASH-driver 2" % filename2)
-        fid2 = open("%s" % filename2, 'w')
-        # get event information needed for HASH-input file
-        try:
-            eventsource = eventinfo.origins[0]
-        except:
-            print("No source origin calculated yet, thus no cnv-file creation possible!")
-            return
-        eventsource = eventinfo.origins[0]
-        event = parameter.get('eventID')
-        hashID = event.split('.')[0][1:5]
-        latdeg = eventsource['latitude']
-        latmin = eventsource['latitude'] * 60 / 10000
-        londeg = eventsource['longitude']
-        lonmin = eventsource['longitude'] * 60 / 10000
-        erh = 1 / 2 * (eventsource.origin_uncertainty['min_horizontal_uncertainty'] +
-                       eventsource.origin_uncertainty['max_horizontal_uncertainty']) / 1000
-        erz = eventsource.depth_errors['uncertainty']
-        stime = eventsource['time']
-        if stime.year - 2000 >= 0:
-            syear = stime.year - 2000
-        else:
-            syear = stime.year - 1900
-        picks = eventinfo.picks
-        # write header line including event information
-        # for HASH-driver 1
-        fid1.write('%s%02d%02d%02d%02d%5.2f%2dN%5.2f%3dE%5.2f%6.3f%4.2f%5.2f%5.2f%s\n' % (syear,
-                                                                                          stime.month, stime.day,
-                                                                                          stime.hour, stime.minute,
-                                                                                          stime.second,
-                                                                                          latdeg, latmin, londeg,
-                                                                                          lonmin, eventsource['depth'],
-                                                                                          eventinfo.magnitudes[0][
-                                                                                              'mag'], erh, erz,
-                                                                                          hashID))
-        # write header line including event information
-        # for HASH-driver 2
-        fid2.write(
-            '%d%02d%02d%02d%02d%5.2f%dN%5.2f%3dE%6.2f%5.2f    %d                                          %5.2f %5.2f                                        %4.2f      %s \n' % (
-                syear, stime.month, stime.day,
-                stime.hour, stime.minute, stime.second,
-                latdeg, latmin, londeg, lonmin,
-                eventsource['depth'],
-                eventsource['quality']['used_phase_count'],
-                erh, erz, eventinfo.magnitudes[0]['mag'],
-                hashID))
-        # Prefer Manual Picks over automatic ones if possible
-        arrivals = chooseArrivals(arrivals)  # MP MP what is chooseArrivals? It is not defined anywhere
-        # write phase lines
-        for key in arrivals:
-            if 'P' in arrivals[key]:
-                if arrivals[key]['P']['weight'] < 4 and arrivals[key]['P']['fm'] is not None:
-                    stat = key
-                    ccode = arrivals[key]['P']['channel']
-                    ncode = arrivals[key]['P']['network']
-
-                    if arrivals[key]['P']['weight'] < 2:
-                        Pqual = 'I'
-                    else:
-                        Pqual = 'E'
-
-                    for i in range(len(picks)):
-                        station = picks[i].waveform_id.station_code
-                        if station == stat:
-                            # get resource ID
-                            resid_picks = picks[i].get('resource_id')
-                            # find same ID in eventinfo
-                            # there it is the pick_id!!
-                            for j in range(len(eventinfo.origins[0].arrivals)):
-                                resid_eventinfo = eventinfo.origins[0].arrivals[j].get('pick_id')
-                                if resid_eventinfo == resid_picks and eventinfo.origins[0].arrivals[j].phase == 'P':
-                                    if len(stat) > 4:  # HASH handles only 4-string station IDs
-                                        stat = stat[1:5]
-                                    az = eventinfo.origins[0].arrivals[j].get('azimuth')
-                                    inz = eventinfo.origins[0].arrivals[j].get('takeoff_angle')
-                                    dist = eventinfo.origins[0].arrivals[j].get('distance')
-                                    # write phase line for HASH-driver 1
-                                    fid1.write(
-                                        '%-4s%sP%s%d                   0                                   %3.1f          %03d %03d   2     1   %s\n' % (
-                                            stat, Pqual, arrivals[key]['P']['fm'], arrivals[key]['P']['weight'],
-                                            dist, inz, az, ccode))
-                                    # write phase line for HASH-driver 2
-                                    fid2.write('%-4s %s   %s %s %s                    \n' % (
-                                        stat,
-                                        ncode,
-                                        ccode,
-                                        Pqual,
-                                        arrivals[key]['P']['fm']))
-                                    break
-
-        fid1.write('                                    %s' % hashID)
-        fid1.close()
-        fid2.close()
 
 
 def chooseArrivals(arrivals):
@@ -1122,7 +670,7 @@ def getQualitiesfromxml(path, errorsP, errorsS, plotflag=1, figure=None, verbosi
                 mstation = pick.waveform_id.station_code
                 mstation_ext = mstation + '_'
                 for mpick in arrivals_copy:
-                    phase = identifyPhase(loopIdentifyPhase(pick.phase_hint)) # MP MP catch if this fails?
+                    phase = identifyPhase(loopIdentifyPhase(pick.phase_hint))  # MP MP catch if this fails?
                     if ((mpick.waveform_id.station_code == mstation) or
                         (mpick.waveform_id.station_code == mstation_ext)) and \
                             (mpick.method_id.id.split('/')[1] == 'auto') and \

pylot/core/io/project.py

@@ -0,0 +1,177 @@
+import os
+
+from pylot.core.util.event import Event
+
+
+class Project(object):
+    '''
+    Pickable class containing information of a PyLoT project, like event lists and file locations.
+    '''
+
+    # TODO: remove rootpath
+    def __init__(self):
+        self.eventlist = []
+        self.location = None
+        self.rootpath = None
+        self.datapath = None
+        self.dirty = False
+        self.parameter = None
+        self._table = None
+
+    def add_eventlist(self, eventlist):
+        '''
+        Add events from an eventlist containing paths to event directories.
+        Will skip existing paths.
+        '''
+        if len(eventlist) == 0:
+            return
+        for item in eventlist:
+            event = Event(item)
+            event.rootpath = self.parameter['rootpath']
+            event.database = self.parameter['database']
+            event.datapath = self.parameter['datapath']
+            if not event.path in self.getPaths():
+                self.eventlist.append(event)
+                self.setDirty()
+            else:
+                print('Skipping event with path {}. Already part of project.'.format(event.path))
+        self.eventlist.sort(key=lambda x: x.pylot_id)
+        self.search_eventfile_info()
+
+    def remove_event(self, event):
+        self.eventlist.remove(event)
+
+    def remove_event_by_id(self, eventID):
+        for event in self.eventlist:
+            if eventID in str(event.resource_id):
+                self.remove_event(event)
+                break
+
+    def read_eventfile_info(self, filename, separator=','):
+        '''
+        Try to read event information from file (:param:filename) comparing specific event datetimes.
+        File structure (each row): event, date, time, magnitude, latitude, longitude, depth
+        separated by :param:separator each.
+        '''
+        with open(filename, 'r') as infile:
+            for line in infile.readlines():
+                eventID, date, time, mag, lat, lon, depth = line.split(separator)[:7]
+                # skip first line
+                try:
+                    day, month, year = date.split('/')
+                except:
+                    continue
+                year = int(year)
+                # hardcoded, if year only consists of 2 digits (e.g. 16 instead of 2016)
+                if year < 100:
+                    year += 2000
+                datetime = '{}-{}-{}T{}'.format(year, month, day, time)
+                try:
+                    datetime = UTCDateTime(datetime)
+                except Exception as e:
+                    print(e, datetime, filename)
+                    continue
+                for event in self.eventlist:
+                    if eventID in str(event.resource_id) or eventID in event.origins:
+                        if event.origins:
+                            origin = event.origins[0]  # should have only one origin
+                            if origin.time == datetime:
+                                origin.latitude = float(lat)
+                                origin.longitude = float(lon)
+                                origin.depth = float(depth)
+                            else:
+                                continue
+                        elif not event.origins:
+                            origin = Origin(resource_id=event.resource_id,
+                                            time=datetime, latitude=float(lat),
+                                            longitude=float(lon), depth=float(depth))
+                            event.origins.append(origin)
+                        event.magnitudes.append(Magnitude(resource_id=event.resource_id,
+                                                          mag=float(mag),
+                                                          mag_type='M'))
+                        break
+
+    def search_eventfile_info(self):
+        '''
+        Search all datapaths in rootpath for filenames with given file extension fext
+        and try to read event info from it
+        '''
+        datapaths = []
+        fext = '.csv'
+        for event in self.eventlist:
+            if not event.datapath in datapaths:
+                datapaths.append(event.datapath)
+        for datapath in datapaths:
+            # datapath = os.path.join(self.rootpath, datapath)
+            if os.path.isdir(datapath):
+                for filename in os.listdir(datapath):
+                    filename = os.path.join(datapath, filename)
+                    if os.path.isfile(filename) and filename.endswith(fext):
+                        try:
+                            self.read_eventfile_info(filename)
+                        except Exception as e:
+                            print('Failed on reading eventfile info from file {}: {}'.format(filename, e))
+            else:
+                print("Directory %s does not exist!" % datapath)
+
+    def getPaths(self):
+        '''
+        Returns paths (eventlist) of all events saved in the project.
+        '''
+        paths = []
+        for event in self.eventlist:
+            paths.append(event.path)
+        return paths
+
+    def setDirty(self, value=True):
+        self.dirty = value
+
+    def getEventFromPath(self, path):
+        '''
+        Search for an event in the project by event path.
+        '''
+        for event in self.eventlist:
+            if event.path == path:
+                return event
+
+    def save(self, filename=None):
+        '''
+        Save PyLoT Project to a file.
+        Can be loaded by using project.load(filename).
+        '''
+        try:
+            import pickle
+        except ImportError:
+            import _pickle as pickle
+
+        if filename:
+            self.location = filename
+        else:
+            filename = self.location
+
+        table = self._table  # MP: see below
+        try:
+            outfile = open(filename, 'wb')
+            self._table = []  # MP: Workaround as long as table cannot be saved as part of project
+            pickle.dump(self, outfile, protocol=pickle.HIGHEST_PROTOCOL)
+            self.setDirty(False)
+            self._table = table  # MP: see above
+            return True
+        except Exception as e:
+            print('Could not pickle PyLoT project. Reason: {}'.format(e))
+            self.setDirty()
+            self._table = table  # MP: see above
+            return False
+
+    @staticmethod
+    def load(filename):
+        '''
+        Load project from filename.
+        '''
+        import pickle
+        infile = open(filename, 'rb')
+        project = pickle.load(infile)
+        infile.close()
+        project.location = filename
+        print('Loaded %s' % filename)
+        return project

pylot/core/io/utils.py

@@ -0,0 +1,13 @@
+import os
+from typing import List
+
+
+def validate_filenames(filenames: List[str]) -> List[str]:
+    """
+    validate a list of filenames for file abundance
+    :param filenames: list of possible filenames
+    :type filenames: List[str]
+    :return: list of valid filenames
+    :rtype: List[str]
+    """
+    return [fn for fn in filenames if os.path.isfile(fn)]

pylot/core/io/waveformdata.py

@@ -0,0 +1,123 @@
+import logging
+from dataclasses import dataclass, field
+from typing import Union, List
+
+from obspy import Stream, read
+from obspy.io.sac import SacIOError
+
+from pylot.core.io.utils import validate_filenames
+from pylot.core.util.dataprocessing import Metadata
+from pylot.core.util.utils import get_stations, check_for_nan, check4rotated
+
+
+@dataclass
+class WaveformData:
+    wfdata: Stream = field(default_factory=Stream)
+    wforiginal: Union[Stream, None] = None
+    wf_alt: Stream = field(default_factory=Stream)
+    dirty: bool = False
+
+    def load_waveforms(self, fnames: List[str], fnames_alt: List[str] = None, check_rotated=False, metadata=None, tstart=0, tstop=0):
+        fn_list = validate_filenames(fnames)
+        if not fn_list:
+            logging.warning('No valid filenames given for loading waveforms')
+        else:
+            self.clear()
+            self.add_waveforms(fn_list)
+
+        if fnames_alt is None:
+            pass
+        else:
+            alt_fn_list = validate_filenames(fnames_alt)
+            if not alt_fn_list:
+                logging.warning('No valid alternative filenames given for loading waveforms')
+            else:
+                self.add_waveforms(alt_fn_list, alternative=True)
+
+        if not fn_list and not alt_fn_list:
+            logging.error('No filenames or alternative filenames given for loading waveforms')
+            return False
+
+        self.merge()
+        self.replace_nan()
+        if not check_rotated or not metadata:
+            pass
+        else:
+            self.rotate_zne()
+        self.trim_station_traces()
+        self.wforiginal = self.wfdata.copy()
+        self.dirty = False
+        return True
+
+    def add_waveforms(self, fnames: List[str], alternative: bool = False):
+        data_stream = self.wf_alt if alternative else self.wfdata
+        warnmsg = ''
+        for fname in set(fnames):
+            try:
+                data_stream += read(fname)
+            except TypeError:
+                try:
+                    data_stream += read(fname, format='GSE2')
+                except Exception as e:
+                    try:
+                        data_stream += read(fname, format='SEGY')
+                    except Exception as e:
+                        warnmsg += f'{fname}\n{e}\n'
+            except SacIOError as se:
+                warnmsg += f'{fname}\n{se}\n'
+
+        if warnmsg:
+            print(f'WARNING in add_waveforms: unable to read waveform data\n{warnmsg}')
+
+    def clear(self):
+        self.wfdata = Stream()
+        self.wforiginal = None
+        self.wf_alt = Stream()
+
+    def reset(self):
+        """
+        Resets the waveform data to its original state.
+        """
+        if self.wforiginal:
+            self.wfdata = self.wforiginal.copy()
+        else:
+            self.wfdata = Stream()
+        self.dirty = False
+
+    def merge(self):
+        """
+        check for gaps in Stream and merge if gaps are found
+        """
+        gaps = self.wfdata.get_gaps()
+        if gaps:
+            merged = ['{}.{}.{}.{}'.format(*gap[:4]) for gap in gaps]
+            self.wfdata.merge(method=1)
+            logging.info('Merged the following stations because of gaps:')
+            for station in merged:
+                logging.info(station)
+
+    def replace_nan(self):
+        """
+        Replace all NaNs in data with 0. (in place)
+        """
+        self.wfdata = check_for_nan(self.wfdata)
+
+    def rotate_zne(self, metadata: Metadata = None):
+        """
+        Check all traces in stream for rotation. If a trace is not in ZNE rotation (last symbol of channel code is numeric) and the trace
+        is in the metadata with azimuth and dip, rotate it to classical ZNE orientation.
+        Rotating the traces requires them to be of the same length, so, all traces will be trimmed to a common length as a
+        side effect.
+        """
+
+        self.wfdata = check4rotated(self.wfdata, metadata)
+
+    def trim_station_traces(self):
+        """
+        trim data stream to common time window
+        """
+
+        for station in get_stations(self.wfdata):
+            station_traces = self.wfdata.select(station=station)
+            station_traces.trim(starttime=max([trace.stats.starttime for trace in station_traces]),
+                                endtime=min([trace.stats.endtime for trace in station_traces]))

pylot/core/loc/focmec.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 
 __version__ = _getVersionString()
@@ -25,4 +25,4 @@ def export(picks, fnout, parameter, eventinfo):
     :type eventinfo:  list object
     '''
     # write phases to FOCMEC-phase file
-    writephases(picks, 'FOCMEC', fnout, parameter, eventinfo)
+    write_phases(picks, 'FOCMEC', fnout, parameter, eventinfo)

pylot/core/loc/hash.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 
 __version__ = _getVersionString()
@@ -25,4 +25,4 @@ def export(picks, fnout, parameter, eventinfo):
     :type eventinfo:  list object
     '''
     # write phases to HASH-phase file
-    writephases(picks, 'HASH', fnout, parameter, eventinfo)
+    write_phases(picks, 'HASH', fnout, parameter, eventinfo)

pylot/core/loc/hypo71.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 
 __version__ = _getVersionString()
@@ -22,4 +22,4 @@ def export(picks, fnout, parameter):
     :type parameter:  object
     '''
     # write phases to HYPO71-phase file
-    writephases(picks, 'HYPO71', fnout, parameter)
+    write_phases(picks, 'HYPO71', fnout, parameter)

pylot/core/loc/hypodd.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 
 __version__ = _getVersionString()
@@ -25,4 +25,4 @@ def export(picks, fnout, parameter, eventinfo):
     :type eventinfo:  list object
     '''
     # write phases to hypoDD-phase file
-    writephases(picks, 'HYPODD', fnout, parameter, eventinfo)
+    write_phases(picks, 'HYPODD', fnout, parameter, eventinfo)

pylot/core/loc/hyposat.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 
 __version__ = _getVersionString()
@@ -22,4 +22,4 @@ def export(picks, fnout, parameter):
     :type parameter:  object
     '''
     # write phases to HYPOSAT-phase file
-    writephases(picks, 'HYPOSAT', fnout, parameter)
+    write_phases(picks, 'HYPOSAT', fnout, parameter)

pylot/core/loc/nll.py

@@ -7,7 +7,7 @@ import subprocess
 
 from obspy import read_events
 
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.gui import which
 from pylot.core.util.utils import getPatternLine, runProgram
 from pylot.core.util.version import get_git_version as _getVersionString
@@ -34,7 +34,7 @@ def export(picks, fnout, parameter):
     :type parameter:  object
     '''
     # write phases to NLLoc-phase file
-    writephases(picks, 'NLLoc', fnout, parameter)
+    write_phases(picks, 'NLLoc', fnout, parameter)
 
 
 def modify_inputs(ctrfn, root, nllocoutn, phasefn, tttn):

pylot/core/loc/velest.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from pylot.core.io.phases import writephases
+from pylot.core.io.phases import write_phases
 from pylot.core.util.version import get_git_version as _getVersionString
 
 __version__ = _getVersionString()
@@ -25,4 +25,4 @@ def export(picks, fnout, eventinfo, parameter=None):
     :type parameter:  object
     '''
     # write phases to VELEST-phase file
-    writephases(picks, 'VELEST', fnout, parameter, eventinfo)
+    write_phases(picks, 'VELEST', fnout, parameter, eventinfo)

pylot/core/util/array_map.py

@@ -474,8 +474,8 @@ class Array_map(QtWidgets.QWidget):
                                                                   transform=ccrs.PlateCarree(), label='deleted'))
 
     def openPickDlg(self, ind):
-        wfdata = self._parent.get_data().getWFData()
+        wfdata = self._parent.get_data().get_wf_data()
-        wfdata_comp = self._parent.get_data().getWFDataComp()
+        wfdata_comp = self._parent.get_data().get_wf_dataComp()
         for index in ind:
             network, station = self._station_onpick_ids[index].split('.')[:2]
             pyl_mw = self._parent

pylot/core/util/dataprocessing.py

@@ -338,19 +338,6 @@ class Metadata(object):
         return inv, exc
 
 
-def time_from_header(header):
-    """
-    Function takes in the second line from a .gse file and takes out the date and time from that line.
-    :param header: second line from .gse file
-    :type header: string
-    :return: a list of integers of form [year, month, day, hour, minute, second, microsecond]
-    """
-    timeline = header.split(' ')
-    time = timeline[1].split('/') + timeline[2].split(':')
-    time = time[:-1] + time[-1].split('.')
-    return [int(t) for t in time]
-
-
 def check_time(datetime):
     """
     Function takes in date and time as list and validates it's values by trying to make an UTCDateTime object from it
@@ -388,167 +375,6 @@ def check_time(datetime):
         return False
 
 
-# TODO: change root to datapath
-def get_file_list(root_dir):
-    """
-    Function uses a directorie to get all the *.gse files from it.
-    :param root_dir: a directorie leading to the .gse files
-    :type root_dir: string
-    :return: returns a list of filenames (without path to them)
-    """
-    file_list = glob.glob1(root_dir, '*.gse')
-    return file_list
-
-
-def checks_station_second(datetime, file):
-    """
-    Function uses the given list to check if the parameter 'second' is set to 60 by mistake
-     and sets the time correctly if so. Can only correct time if no date change would be necessary.
-    :param datetime: [year, month, day, hour, minute, second, microsecond]
-    :return: returns the input with the correct value for second
-    """
-    if datetime[5] == 60:
-        if datetime[4] == 59:
-            if datetime[3] == 23:
-                err_msg = 'Date should be next day. ' \
-                          'File not changed: {0}'.format(file)
-                raise ValueError(err_msg)
-            else:
-                datetime[3] += 1
-                datetime[4] = 0
-                datetime[5] = 0
-        else:
-            datetime[4] += 1
-            datetime[5] = 0
-    return datetime
-
-
-def make_time_line(line, datetime):
-    """
-    Function takes in the original line from a .gse file and a list of date and
-    time values to make a new line with corrected date and time.
-    :param line: second line from .gse file.
-    :type line: string
-    :param datetime: list of integers [year, month, day, hour, minute, second, microsecond]
-    :type datetime: list
-    :return: returns a string to write it into a file.
-    """
-    ins_form = '{0:02d}:{1:02d}:{2:02d}.{3:03d}'
-    insertion = ins_form.format(int(datetime[3]),
-                                int(datetime[4]),
-                                int(datetime[5]),
-                                int(datetime[6] * 1e-3))
-    newline = line[:16] + insertion + line[28:]
-    return newline
-
-
-def evt_head_check(root_dir, out_dir=None):
-    """
-    A function to make sure that an arbitrary number of .gse files have correct values in their header.
-    :param root_dir: a directory leading to the .gse files.
-    :type root_dir: string
-    :param out_dir: a directory to store the new files somwhere els.
-    :return: returns nothing
-    """
-    if not out_dir:
-        print('WARNING files are going to be overwritten!')
-        inp = str(input('Continue? [y/N]'))
-        if not inp == 'y':
-            sys.exit()
-    filelist = get_file_list(root_dir)
-    nfiles = 0
-    for file in filelist:
-        infile = open(os.path.join(root_dir, file), 'r')
-        lines = infile.readlines()
-        infile.close()
-        datetime = time_from_header(lines[1])
-        if check_time(datetime):
-            continue
-        else:
-            nfiles += 1
-            datetime = checks_station_second(datetime, file)
-            print('writing ' + file)
-            # write File
-            lines[1] = make_time_line(lines[1], datetime)
-            if not out_dir:
-                out = open(os.path.join(root_dir, file), 'w')
-                out.writelines(lines)
-                out.close()
-            else:
-                out = open(os.path.join(out_dir, file), 'w')
-                out.writelines(lines)
-                out.close()
-    print(nfiles)
-
-
-def read_metadata(path_to_inventory):
-    """
-    take path_to_inventory and return either the corresponding list of files
-    found or the Parser object for a network dataless seed volume to prevent
-    read overhead for large dataless seed volumes
-    :param path_to_inventory:
-    :return: tuple containing a either list of files or `obspy.io.xseed.Parser`
-    object and the inventory type found
-    :rtype: tuple
-    """
-    dlfile = list()
-    invfile = list()
-    respfile = list()
-    # possible file extensions specified here:
-    inv = dict(dless=dlfile, xml=invfile, resp=respfile, dseed=dlfile[:])
-    if os.path.isfile(path_to_inventory):
-        ext = os.path.splitext(path_to_inventory)[1].split('.')[1]
-        inv[ext] += [path_to_inventory]
-    else:
-        for ext in inv.keys():
-            inv[ext] += glob.glob1(path_to_inventory, '*.{0}'.format(ext))
-
-    invtype = key_for_set_value(inv)
-
-    if invtype is None:
-        print("Neither dataless-SEED file, inventory-xml file nor "
-              "RESP-file found!")
-        print("!!WRONG CALCULATION OF SOURCE PARAMETERS!!")
-        robj = None,
-    elif invtype == 'dless':  # prevent multiple read of large dlsv
-        print("Reading metadata information from dataless-SEED file ...")
-        if len(inv[invtype]) == 1:
-            fullpath_inv = os.path.join(path_to_inventory, inv[invtype][0])
-            robj = Parser(fullpath_inv)
-        else:
-            robj = inv[invtype]
-    else:
-        print("Reading metadata information from inventory-xml file ...")
-        robj = read_inventory(inv[invtype])
-    return invtype, robj
-
-
-# idea to optimize read_metadata
-# def read_metadata_new(path_to_inventory):
-#     metadata_objects = []
-#     # read multiple files from directory
-#     if os.path.isdir(path_to_inventory):
-#         fnames = os.listdir(path_to_inventory)
-#     # read single file
-#     elif os.path.isfile(path_to_inventory):
-#         fnames = [path_to_inventory]
-#     else:
-#         print("Neither dataless-SEED file, inventory-xml file nor "
-#               "RESP-file found!")
-#         print("!!WRONG CALCULATION OF SOURCE PARAMETERS!!")
-#         fnames = []
-#
-#     for fname in fnames:
-#         path_to_inventory_filename = os.path.join(path_to_inventory, fname)
-#         try:
-#             ftype, robj = read_metadata_file(path_to_inventory_filename)
-#             metadata_objects.append((ftype, robj))
-#         except Exception as e:
-#             print('Could not read metadata file {} '
-#                   'because of the following Exception: {}'.format(path_to_inventory_filename, e))
-#     return metadata_objects
-
-
 def restitute_trace(input_tuple):
     def no_metadata(tr, seed_id):
         print('no metadata file found '

pylot/core/util/generate_array_maps.py

@@ -20,7 +20,7 @@ import matplotlib
 matplotlib.use('Qt5Agg')
 sys.path.append(os.path.join('/'.join(sys.argv[0].split('/')[:-1]), '../../..'))
 
-from PyLoT import Project
+from pylot.core.io.project import Project
 from pylot.core.util.dataprocessing import Metadata
 from pylot.core.util.array_map import Array_map
 

pylot/core/util/structure.py

@@ -6,7 +6,7 @@ Created on Wed Jan 26 17:47:25 2015
 @author: sebastianw
 """
 
-from pylot.core.io.data import SeiscompDataStructure, PilotDataStructure, ObspyDMTdataStructure
+from pylot.core.io.data import SeiscompDataStructure, PilotDataStructure
 
 DATASTRUCTURE = {'PILOT': PilotDataStructure, 'SeisComP': SeiscompDataStructure,
-                 'obspyDMT': ObspyDMTdataStructure, None: PilotDataStructure}
+                 'obspyDMT': PilotDataStructure, None: PilotDataStructure}

pylot/core/util/utils.py

@@ -358,6 +358,8 @@ def get_bool(value):
     False
     >>> get_bool(None)
     None
+    >>> get_bool('Stream')
+    'Stream'
     """
     if type(value) is bool:
         return value

pylot/core/util/widgets.py

@@ -140,18 +140,6 @@ class LogWidget(QtWidgets.QWidget):
         self.stderr.append(60 * '#' + '\n\n')
 
 
-def getDataType(parent):
-    type = QInputDialog().getItem(parent, "Select phases type", "Type:",
-                                  ["manual", "automatic"])
-
-    if type[0].startswith('auto'):
-        type = 'auto'
-    else:
-        type = type[0]
-
-    return type
-
-
 def plot_pdf(_axes, x, y, annotation, bbox_props, xlabel=None, ylabel=None,
              title=None):
     # try method or data
@@ -1009,15 +997,6 @@ class WaveformWidgetPG(QtWidgets.QWidget):
         time_ax = np.linspace(time_ax[0], time_ax[-1], num=len(data))
         return data, time_ax
 
-    # def getAxes(self):
-    #     return self.axes
-
-    # def getXLims(self):
-    #     return self.getAxes().get_xlim()
-
-    # def getYLims(self):
-    #     return self.getAxes().get_ylim()
-
     def setXLims(self, lims):
         vb = self.plotWidget.getPlotItem().getViewBox()
         vb.setXRange(float(lims[0]), float(lims[1]), padding=0)
@@ -1171,8 +1150,6 @@ class PylotCanvas(FigureCanvas):
                 break
         if not ax_check: return
 
-        # self.updateCurrentLimits() #maybe put this down to else:
-
         # calculate delta (relative values in axis)
         old_x, old_y = self.press_rel
         xdiff = gui_event.x - old_x
@@ -1380,125 +1357,140 @@ class PylotCanvas(FigureCanvas):
                    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):
+        ax = self.prepare_plot()
-            return dict(data=data, linecolor=linecolor, offset=offset, plot_kwargs=plot_kwargs)
+        self.clearPlotDict()
 
+        wfstart, wfend = self.get_wf_range(wfdata)
+        compclass = self.get_comp_class()
+        plot_streams = self.get_plot_streams(wfdata, wfdata_compare, component, compclass)
 
+        st_main = plot_streams['wfdata']['data']
+        if mapping:
+            plot_positions = self.calcPlotPositions(st_main, compclass)
+
+        nslc = self.get_sorted_nslc(st_main)
+        nmax = self.plot_traces(ax, plot_streams, nslc, wfstart, mapping, plot_positions,
+                                scaleToChannel, noiselevel, scaleddata, nth_sample, verbosity)
+
+        if plot_additional and additional_channel:
+            self.plot_additional_trace(ax, wfdata, additional_channel, scaleToChannel,
+                                       scaleddata, nth_sample, wfstart)
+
+        self.finalize_plot(ax, wfstart, wfend, nmax, zoomx, zoomy, iniPick, title, snr)
+
+    def prepare_plot(self):
         ax = self.axes[0]
         ax.cla()
+        return ax
 
-        self.clearPlotDict()
+    def get_wf_range(self, wfdata):
-        wfstart, wfend = full_range(wfdata)
+        return full_range(wfdata)
-        nmax = 0
 
+    def get_comp_class(self):
         settings = QSettings()
-        compclass = SetChannelComponents.from_qsettings(settings)
+        return SetChannelComponents.from_qsettings(settings)
+
+    def get_plot_streams(self, wfdata, wfdata_compare, component, compclass):
+        def get_wf_dict(data=Stream(), linecolor='k', offset=0., **plot_kwargs):
+            return dict(data=data, linecolor=linecolor, offset=offset, plot_kwargs=plot_kwargs)
 
         linecolor = (0., 0., 0., 1.) if not self.style else self.style['linecolor']['rgba_mpl']
+        plot_streams = {
+            '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)
+        }
 
-        plot_streams = dict(wfdata=get_wf_dict(linecolor=linecolor, linewidth=0.7),
+        if component != '*':
-                            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) + wfdata.select(component=alter_comp)
-
-            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(
-                plot_streams['wfdata_comp']['data'] += wfdata_compare.select(component=alter_comp)
+                    component=component) + wfdata_compare.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']
+        return plot_streams
 
-        if mapping:
+    def get_sorted_nslc(self, st_main):
-            plot_positions = self.calcPlotPositions(st_main, compclass)
+        nslc = [trace.get_id() for trace in st_main if trace.stats.channel[-1] in ['Z', 'N', 'E', '1', '2', '3']]
-
+        nslc.sort(reverse=True)
-        # list containing tuples of network, station, channel and plot position (for sorting)
+        return nslc
-        nslc = []
-        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
-            nslc.append(trace.get_id())
-        nslc.sort()
-        nslc.reverse()
 
+    def plot_traces(self, ax, plot_streams, nslc, wfstart, mapping, plot_positions, scaleToChannel, noiselevel,
+                    scaleddata, nth_sample, verbosity):
+        nmax = 0
         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_select.select(id=seed_id)[0].copy()
-                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(f'plotting {channel} channel of station {station}')
-                    print(msg)
+                time_ax = prep_time_axis(trace.stats.starttime - wfstart, trace)
-                stime = trace.stats.starttime - wfstart
+                self.plot_trace(ax, trace, time_ax, wf_dict, n, scaleToChannel, noiselevel, scaleddata, nth_sample)
-                time_ax = prep_time_axis(stime, trace)
+                self.setPlotDict(n, seed_id)
-                if time_ax is not None:
+        return nmax
-                    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(trace.data)) * 2)
 
-                    offset = wf_dict.get('offset')
+    def plot_trace(self, ax, trace, time_ax, wf_dict, n, scaleToChannel, noiselevel, scaleddata, nth_sample):
+        if time_ax is not None:
+            if scaleToChannel:
+                self.scale_trace(trace, scaleToChannel)
+                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]
+            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]
+            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.axhline(n, color="0.5", lw=0.5)
-                    ax.plot(times, data, color=wf_dict.get('linecolor'), **wf_dict.get('plot_kwargs'))
+            ax.plot(times, data, color=wf_dict.get('linecolor'), **wf_dict.get('plot_kwargs'))
-                    if noiselevel is not None:
+            if noiselevel is not None:
-                        for level in [-noiselevel[channel], noiselevel[channel]]:
+                self.plot_noise_level(ax, time_ax, noiselevel, channel, n, wf_dict.get('linecolor'))
-                            ax.plot([time_ax[0], time_ax[-1]],
-                                    [n + level, n + level],
-                                    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:
-                trace = compare_stream[0]
-                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(trace.data)) * 2)
-                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
-                # p_max = max(abs(p_data))
-                # p_data /= p_max
-                for index in range(3):
-                    ax.plot(times, p_data, color='red', alpha=0.5, linewidth=0.7)
-                    p_data += 1
 
+    def scale_trace(self, trace, 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)
+
+    def plot_noise_level(self, ax, time_ax, noiselevel, channel, n, linecolor):
+        for level in [-noiselevel[channel], noiselevel[channel]]:
+            ax.plot([time_ax[0], time_ax[-1]], [n + level, n + level], color=linecolor, linestyle='dashed')
+
+    def plot_additional_trace(self, ax, wfdata, additional_channel, scaleToChannel, scaleddata, nth_sample, wfstart):
+        compare_stream = wfdata.select(channel=additional_channel)
+        if compare_stream:
+            trace = compare_stream[0]
+            if scaleToChannel:
+                self.scale_trace(trace, scaleToChannel)
+                scaleddata = True
+            if not scaleddata:
+                trace.detrend('constant')
+                trace.normalize(np.max(np.abs(trace.data)) * 2)
+            time_ax = prep_time_axis(trace.stats.starttime - wfstart, trace)
+            self.plot_additional_data(ax, trace, time_ax, nth_sample)
+
+    def plot_additional_data(self, ax, trace, time_ax, nth_sample):
+        times = [time for index, time in enumerate(time_ax) if not index % nth_sample]
+        p_data = trace.data
+        for index in range(3):
+            ax.plot(times, p_data, color='red', alpha=0.5, linewidth=0.7)
+            p_data += 1
+
+    def finalize_plot(self, ax, wfstart, wfend, nmax, zoomx, zoomy, iniPick, title, snr):
         if iniPick:
-            ax.vlines(iniPick, ax.get_ylim()[0], ax.get_ylim()[1],
+            ax.vlines(iniPick, ax.get_ylim()[0], ax.get_ylim()[1], colors='m', linestyles='dashed', linewidth=2)
-                      colors='m', linestyles='dashed',
+        xlabel = f'seconds since {wfstart}'
-                      linewidth=2)
-        xlabel = 'seconds since {0}'.format(wfstart)
         ylabel = ''
         self.updateWidget(xlabel, ylabel, title)
         self.setXLims(ax, [0, wfend - wfstart])
@@ -1508,15 +1500,14 @@ class PylotCanvas(FigureCanvas):
         if zoomy is not None:
             self.setYLims(ax, zoomy)
         if snr is not None:
-            if snr < 2:
+            self.plot_snr_warning(ax, snr)
-                warning = 'LOW SNR'
-                if snr < 1.5:
-                    warning = 'VERY LOW SNR'
-                ax.text(0.1, 0.9, 'WARNING - {}'.format(warning), ha='center', va='center', transform=ax.transAxes,
-                        color='red')
-
         self.draw()
 
+    def plot_snr_warning(self, ax, snr):
+        if snr < 2:
+            warning = 'LOW SNR' if snr >= 1.5 else 'VERY LOW SNR'
+            ax.text(0.1, 0.9, f'WARNING - {warning}', ha='center', va='center', transform=ax.transAxes, color='red')
+
     @staticmethod
     def getXLims(ax):
         return ax.get_xlim()
@@ -1921,7 +1912,7 @@ class PickDlg(QDialog):
         # set attribute holding data
         if data is None or not data:
             try:
-                data = parent.get_data().getWFData().copy()
+                data = parent.get_data().get_wf_data().copy()
                 self.data = data.select(station=station)
             except AttributeError as e:
                 errmsg = 'You either have to put in a data or an appropriate ' \
@@ -1955,7 +1946,7 @@ class PickDlg(QDialog):
         self.cur_xlim = None
         self.cur_ylim = None
 
-        self.stime, self.etime = full_range(self.getWFData())
+        self.stime, self.etime = full_range(self.get_wf_data())
 
         # initialize plotting widget
         self.multicompfig = PylotCanvas(parent=self, multicursor=True)
@@ -1969,7 +1960,7 @@ class PickDlg(QDialog):
         self.referenceChannel.addItem('-', None)
         self.scaleChannel.addItem('individual', None)
 
-        for trace in self.getWFData():
+        for trace in self.get_wf_data():
             channel = trace.stats.channel
             self.referenceChannel.addItem(channel, trace)
             if not channel[-1] in ['Z', 'N', 'E', '1', '2', '3']:
@@ -1988,7 +1979,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.get_wf_data(), wfdata_compare=self.get_wf_dataComp(),
                                      title=title)
 
         self.multicompfig.setZoomBorders2content()
@@ -2523,7 +2514,7 @@ class PickDlg(QDialog):
         if self.autoFilterAction.isChecked():
             for filteraction in [self.filterActionP, self.filterActionS]:
                 filteraction.setChecked(False)
-            self.filterWFData()
+            self.filter_wf_data()
             self.draw()
         else:
             self.draw()
@@ -2607,10 +2598,10 @@ class PickDlg(QDialog):
     def getGlobalLimits(self, ax, axis):
         return self.multicompfig.getGlobalLimits(ax, axis)
 
-    def getWFData(self):
+    def get_wf_data(self):
         return self.data
 
-    def getWFDataComp(self):
+    def get_wf_dataComp(self):
         if self.showCompData:
             return self.data_compare
         else:
@@ -2625,17 +2616,17 @@ class PickDlg(QDialog):
                 return tr
 
         if component == 'E' or component == 'N':
-            for trace in self.getWFData():
+            for trace in self.get_wf_data():
                 trace = selectTrace(trace, 'NE')
                 if trace:
                     wfdata.append(trace)
         elif component == '1' or component == '2':
-            for trace in self.getWFData():
+            for trace in self.get_wf_data():
                 trace = selectTrace(trace, '12')
                 if trace:
                     wfdata.append(trace)
         else:
-            wfdata = self.getWFData().select(component=component)
+            wfdata = self.get_wf_data().select(component=component)
         return wfdata
 
     def getPicks(self, picktype='manual'):
@@ -2738,8 +2729,8 @@ class PickDlg(QDialog):
         stime = self.getStartTime()
 
         # copy wfdata for plotting
-        wfdata = self.getWFData().copy()
+        wfdata = self.get_wf_data().copy()
-        wfdata_comp = self.getWFDataComp().copy()
+        wfdata_comp = self.get_wf_dataComp().copy()
         wfdata = self.getPickPhases(wfdata, phase)
         wfdata_comp = self.getPickPhases(wfdata_comp, phase)
         for wfd in [wfdata, wfdata_comp]:
@@ -2848,7 +2839,7 @@ class PickDlg(QDialog):
             filteroptions = None
 
         # copy and filter data for earliest and latest possible picks
-        wfdata = self.getWFData().copy().select(channel=channel)
+        wfdata = self.get_wf_data().copy().select(channel=channel)
         if filteroptions:
             try:
                 wfdata.detrend('linear')
@@ -2895,7 +2886,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.get_wf_data().select(channel=channel).copy(), wfdata.copy(), parameter.get('fmpickwin'),
                               pick - stime_diff)
 
         # save pick times for actual phase
@@ -3187,7 +3178,7 @@ class PickDlg(QDialog):
     def togglePickBlocker(self):
         return not self.pick_block
 
-    def filterWFData(self, phase=None):
+    def filter_wf_data(self, phase=None):
         if not phase:
             phase = self.currentPhase
             if self.getPhaseID(phase) == 'P':
@@ -3205,8 +3196,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()
-        wfdata = self.getWFData().copy()
+        wfdata = self.get_wf_data().copy()
-        wfdata_comp = self.getWFDataComp().copy()
+        wfdata_comp = self.get_wf_dataComp().copy()
         title = self.getStation()
         if filter:
             filtoptions = None
@@ -3243,14 +3234,14 @@ class PickDlg(QDialog):
     def filterP(self):
         self.filterActionS.setChecked(False)
         if self.filterActionP.isChecked():
-            self.filterWFData('P')
+            self.filter_wf_data('P')
         else:
             self.refreshPlot()
 
     def filterS(self):
         self.filterActionP.setChecked(False)
         if self.filterActionS.isChecked():
-            self.filterWFData('S')
+            self.filter_wf_data('S')
         else:
             self.refreshPlot()
 
@@ -3309,7 +3300,7 @@ class PickDlg(QDialog):
         if self.autoFilterAction.isChecked():
             self.filterActionP.setChecked(False)
             self.filterActionS.setChecked(False)
-        # data = self.getWFData().copy()
+        # data = self.get_wf_data().copy()
         # title = self.getStation()
         filter = False
         phase = None
@@ -3809,8 +3800,8 @@ class TuneAutopicker(QWidget):
         fnames = self.station_ids[self.get_current_station_id()]
         if not fnames == self.fnames:
             self.fnames = fnames
-            self.data.setWFData(fnames)
+            self.data.set_wf_data(fnames)
-            wfdat = self.data.getWFData()  # all available streams
+            wfdat = self.data.get_wf_data()  # all available streams
             # remove possible underscores in station names
             # wfdat = remove_underscores(wfdat)
             # rotate misaligned stations to ZNE
@@ -3915,8 +3906,8 @@ class TuneAutopicker(QWidget):
             network = None
             location = None
 
-        wfdata = self.data.getWFData()
+        wfdata = self.data.get_wf_data()
-        wfdata_comp = self.data.getWFDataComp()
+        wfdata_comp = self.data.get_wf_dataComp()
         metadata = self.parent().metadata
         event = self.get_current_event()
         filteroptions = self.parent().filteroptions
@@ -3971,7 +3962,7 @@ class TuneAutopicker(QWidget):
         for plotitem in self._manual_pick_plots:
             self.clear_plotitem(plotitem)
         self._manual_pick_plots = []
-        st = self.data.getWFData()
+        st = self.data.get_wf_data()
         tr = st.select(station=self.get_current_station())[0]
         starttime = tr.stats.starttime
         # create two lists with figure names and subindices (for subplots) to get the correct axes