[update] some general bugfixes and improvements in array map

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

README.md

@@ -11,7 +11,7 @@ PILOT has originally been developed in Mathworks' MatLab. In order to distribute
 problems, it has been decided to redevelop the software package in Python. The great work of the ObsPy group allows easy
 handling of a bunch of seismic data and PyLoT will benefit a lot compared to the former MatLab version.
 
-The development of PyLoT is part of the joint research project MAGS2 and AlpArray.
+The development of PyLoT is part of the joint research project MAGS2, AlpArray and AdriaArray.
 
 ## Installation
 
@@ -27,28 +27,30 @@ Afterwards run (from the PyLoT main directory where the files *requirements.txt*
     conda env create -f pylot.yml
 or
     
-    conda create --name pylot_38 --file requirements.txt
+    conda create -c conda-forge --name pylot_311 python=3.11 --file requirements.txt
 
-to create a new Anaconda environment called "pylot_38".
+to create a new Anaconda environment called *pylot_311*.
 
 Afterwards activate the environment by typing
 
-    conda activate pylot_38
+    conda activate pylot_311
 
 #### Prerequisites:
 
 In order to run PyLoT you need to install:
 
 - Python 3
-- obspy
-- pyside2
-- pyqtgraph
 - cartopy
+- joblib
+- obspy
+- pyaml
+- pyqtgraph
+- pyside2
 
 (the following are already dependencies of the above packages):
 - scipy
 - numpy
-- matplotlib <= 3.3.x
+- matplotlib
 
 #### Some handwork:
 
@@ -108,4 +110,4 @@ Others: A. Bruestle, T. Meier, W. Friederich
 
 [ObsPy]: http://github.com/obspy/obspy/wiki
 
-April 2022
+August 2024

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.set_wf_data(glob.glob(os.path.join(datapath, event_datapath, '*')))
+                data.setWFData(glob.glob(os.path.join(datapath, event_datapath, '*')))
                 # the following is necessary because within
                 # multiple event processing no event ID is provided
                 # in autopylot.in
@@ -258,7 +258,7 @@ def autoPyLoT(input_dict=None, parameter=None, inputfile=None, fnames=None, even
                                                       now.minute)
                     parameter.setParam(eventID=eventID)
             else:
-                data.set_wf_data(fnames)
+                data.setWFData(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.get_wf_data()  # all available streams
+            wfdat = data.getWFData()  # all available streams
             if not station == 'all':
                 wfdat = wfdat.select(station=station)
                 if not wfdat:

pylot.yml

@@ -1,14 +1,12 @@
-name: pylot_38
+name: pylot_311
 channels:
   - conda-forge
   - defaults
 dependencies:
-  - cartopy=0.20.2
+  - cartopy=0.23.0=py311hcf9f919_1
-  - matplotlib-base=3.3.4
+  - joblib=1.4.2=pyhd8ed1ab_0
-  - numpy=1.22.3
+  - obspy=1.4.1=py311he736701_3
-  - obspy=1.3.0
+  - pyaml=24.7.0=pyhd8ed1ab_0
-  - pyqtgraph=0.12.4
+  - pyqtgraph=0.13.7=pyhd8ed1ab_0
-  - pyside2>=5.13.2
+  - pyside2=5.15.8=py311h3d699ce_4
-  - python=3.8.12
+  - pytest=8.3.2=pyhd8ed1ab_0
-  - qt>=5.12.9
-  - scipy=1.8.0

pylot/core/io/data.py

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

@@ -1,106 +0,0 @@
-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,6 +21,25 @@ 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
@@ -174,6 +193,31 @@ 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
@@ -329,228 +373,636 @@ def picks_from_picksdict(picks, creation_info=None):
     return picks_list
 
 
-def write_phases(arrivals, fformat, filename, parameter=None, eventinfo=None):
+def reassess_pilot_db(root_dir, db_dir, out_dir=None, fn_param=None, verbosity=0):
-    """
+    # TODO: change root to datapath
-    Writes earthquake phase data to different file formats.
+    db_root = os.path.join(root_dir, db_dir)
+    evt_list = glob.glob1(db_root, 'e????.???.??')
 
-    :param arrivals: Dictionary containing phase information (station ID, phase, first motion, weight, etc.)
+    for evt in evt_list:
-    :type arrivals: dict
+        if verbosity > 0:
-    :param fformat: File format to write to (e.g., 'NLLoc', 'HYPO71', 'HYPOSAT', 'VELEST', 'HYPODD', 'FOCMEC')
+            print('Reassessing event {0}'.format(evt))
-    :type fformat: str
+        reassess_pilot_event(root_dir, db_dir, evt, out_dir, fn_param, verbosity)
-    :param filename: Path and name of the output phase file
-    :type filename: str
-    :param parameter: Additional parameters for writing the phase data
-    :type parameter: object
-    :param eventinfo: Event information needed for specific formats like VELEST, FOCMEC, and HASH
-    :type eventinfo: obspy.core.event.Event
-    """
 
-    def write_nlloc():
-        with open(filename, 'w') as fid:
-            fid.write('# EQEVENT: {} Label: EQ{}  Loc:  X 0.00  Y 0.00  Z 10.00  OT 0.00 \n'.format(
-                parameter.get('database'), parameter.get('eventID')))
-            for key, value in arrivals.items():
-                for phase in ['P', 'S']:
-                    if phase in value:
-                        fm = value[phase].get('fm', '?')
-                        onset = value[phase]['mpp']
-                        ss_ms = onset.second + onset.microsecond / 1000000.0
-                        weight = 1 if value[phase].get('weight', 0) < 4 else 0
-                        amp = value[phase].get('Ao', 0.0) if phase == 'S' else ''
-                        fid.write('{} ? ? ? {}   {}{}{} {}{} {:7.4f} GAU 0 {} 0 0 {}\n'.format(
-                            key, phase, fm, onset.year, onset.month, onset.day, onset.hour, onset.minute, ss_ms, amp,
-                            weight))
 
-    def write_hypo71():
+def reassess_pilot_event(root_dir, db_dir, event_id, out_dir=None, fn_param=None, verbosity=0):
-        with open(filename, 'w') as fid:
+    from obspy import read
-            fid.write(
+
-                '                                                                {}\n'.format(parameter.get('eventID')))
+    from pylot.core.io.inputs import PylotParameter
-            for key, value in arrivals.items():
+    from pylot.core.pick.utils import earllatepicker
-                if value['P'].get('weight', 0) < 4:
+    # TODO: change root to datapath
-                    stat = key[:4]
+
-                    Ponset = value['P']['mpp']
+    default = PylotParameter(fn_param, verbosity)
-                    Sonset = value.get('S', {}).get('mpp')
+
-                    pweight = value['P'].get('weight', 0)
+    search_base = os.path.join(root_dir, db_dir, event_id)
-                    sweight = value.get('S', {}).get('weight', 0)
+    phases_file = glob.glob(os.path.join(search_base, 'PHASES.mat'))
-                    fm = value['P'].get('fm', '-')
+    if not phases_file:
-                    Ao = value.get('S', {}).get('Ao', '')
+        return
-                    year = Ponset.year - 2000 if Ponset.year >= 2000 else Ponset.year - 1900
+    if verbosity > 1:
-                    ss_ms = Ponset.second + Ponset.microsecond / 1000000.0
+        print('Opening PILOT phases file: {fn}'.format(fn=phases_file[0]))
-                    if Sonset:
+    picks_dict = picksdict_from_pilot(phases_file[0])
-                        Sss_ms = Sonset.second + Sonset.microsecond / 1000000.0
+    if verbosity > 0:
-                        fid.write('{}P{}{}{} {}{}{}{}{} {:5.2f}       {}{}S {}   {}\n'.format(
+        print('Dictionary read from PHASES.mat:\n{0}'.format(picks_dict))
-                            stat, 'I' if pweight < 2 else 'E', fm, pweight, year, Ponset.month, Ponset.day,
+    datacheck = list()
-                            Ponset.hour, Ponset.minute, ss_ms, Sss_ms, 'I' if sweight < 2 else 'E', sweight, Ao))
+    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:
-                        fid.write('{}P{}{}{} {}{}{}{}{} {:5.2f}                  {}\n'.format(
+                        raise ValueError(e.message)
-                            stat, 'I' if pweight < 2 else 'E', fm, pweight, year, Ponset.month, Ponset.day,
+                except Exception as e:
-                            Ponset.hour, Ponset.minute, ss_ms, Ao))
+                    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 write_hyposat():
-        with open(filename, 'w') as fid:
-            fid.write('{}, event {} \n'.format(parameter.get('database'), parameter.get('eventID')))
-            for key, value in arrivals.items():
-                for phase in ['P', 'S']:
-                    if phase in value and value[phase].get('weight', 0) < 4:
-                        onset = value[phase]['mpp']
-                        ss_ms = onset.second + onset.microsecond / 1000000.0
-                        std = value[phase].get('spe', parameter.get('timeerrorsP')[value[phase].get('weight', 0)])
-                        fid.write(
-                            '{:<5} {}1       {:4} {:02} {:02} {:02} {:02} {:05.02f}   {:5.3f} -999.   0.00 -999.  0.00\n'.format(
-                                key, phase, onset.year, onset.month, onset.day, onset.hour, onset.minute, ss_ms, std))
 
-    def write_velest():
+def writephases(arrivals, fformat, filename, parameter=None, eventinfo=None):
-        if not eventinfo:
+    """
+    Function of methods to write phases to the following standard file
+    formats used for locating earthquakes:
+
+    HYPO71, NLLoc, VELEST, HYPOSAT, FOCMEC, and hypoDD
+
+    :param arrivals:dictionary containing all phase information including
+     station ID, phase, first motion, weight (uncertainty), ...
+    :type arrivals: dict
+
+    :param fformat: chosen file format (location routine),
+    choose between NLLoc, HYPO71, HYPOSAT, VELEST,
+    HYPOINVERSE, FOCMEC, and hypoDD
+    :type fformat: str
+
+    :param filename: full path and name of phase file
+    :type filename:  string
+
+    :param parameter: all input information
+    :type parameter:  object
+
+    :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()
+    elif fformat == 'HYPO71':
+        print("Writing phases to %s for HYPO71" % filename)
+        fid = open("%s" % filename, 'w')
+        # write header
+        fid.write('                                                                %s\n' %
+                  parameter.get('eventID'))
+        arrivals = chooseArrivals(arrivals)  # MP MP what is chooseArrivals? It is not defined anywhere
+        for key in arrivals:
+            if arrivals[key]['P']['weight'] < 4:
+                stat = key
+                if len(stat) > 4:  # HYPO71 handles only 4-string station IDs
+                    stat = stat[1:5]
+                Ponset = arrivals[key]['P']['mpp']
+                Sonset = arrivals[key]['S']['mpp']
+                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()
+
+    elif fformat == 'HYPOSAT':
+        print("Writing phases to %s for HYPOSAT" % filename)
+        fid = open("%s" % filename, 'w')
+        # write header
+        fid.write('%s, event %s \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] and arrivals[key]['P']['mpp'] is not None:
+                if arrivals[key]['P']['weight'] < 4:
+                    Ponset = arrivals[key]['P']['mpp']
+                    pyear = Ponset.year
+                    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':
+        print("Writing phases to %s for VELEST" % filename)
+        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
-        with open(filename, 'w') as fid:
+        if eventsource['latitude'] < 0:
-            origin = eventinfo.origins[0]
+            cns = 'S'
-            lat_dir = 'S' if origin.latitude < 0 else 'N'
+        else:
-            lon_dir = 'W' if origin.longitude < 0 else 'E'
+            cns = 'N'
-            year = origin.time.year - 2000 if origin.time.year >= 2000 else origin.time.year - 1900
+        if eventsource['longitude'] < 0:
-            fid.write(
+            cew = 'W'
-                '{}{}{} {}{} {} {:05.2f} {:7.4f}{} {:8.4f}{} {:7.2f} {:6.2f}     {:02.0f}  0.0 0.03  1.0  1.0\n'.format(
+        else:
-                    year, origin.time.month, origin.time.day, origin.time.hour, origin.time.minute, origin.time.second,
+            cew = 'E'
-                    origin.latitude, lat_dir, origin.longitude, lon_dir, origin.depth, eventinfo.magnitudes[0].mag, 0))
+        # get last two integers of origin year
-            for key, value in arrivals.items():
+        stime = eventsource['time']
-                for phase in ['P', 'S']:
+        if stime.year - 2000 >= 0:
-                    if phase in value and value[phase].get('weight', 0) < 4:
+            syear = stime.year - 2000
-                        onset = value[phase]['mpp']
+        else:
-                        rt = (onset - origin.time).total_seconds()
+            syear = stime.year - 1900
-                        fid.write('{:<4}{}{}{:6.2f}\n'.format(key[:4], phase, value[phase].get('weight', 0), rt))
+        ifx = 0  # default value, see VELEST manual, pp. 22-23
+        # 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()
 
-    def write_hypodd():
+    elif fformat == 'HYPODD':
-        if not eventinfo:
+        print("Writing phases to %s for hypoDD" % filename)
+        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
-        with open(filename, 'w') as fid:
+        stime = eventsource['time']
-            origin = eventinfo.origins[0]
+        try:
-            stime = origin.time
+            event = eventinfo['pylot_id']
-            fid.write('# {}  {} {} {} {} {} {:7.4f} +{:6.4f} {:7.4f} {:4.2f} 0.1 0.5 {:4.2f}      {}\n'.format(
+            hddID = event.split('.')[0][1:5]
-                stime.year, stime.month, stime.day, stime.hour, stime.minute, stime.second,
+        except:
-                origin.latitude, origin.longitude, origin.depth / 1000, eventinfo.magnitudes[0].mag,
+            print("Error 1111111!")
-                origin.quality.standard_error, "00000"))
+            hddID = "00000"
-            for key, value in arrivals.items():
+            # write header
-                for phase in ['P', 'S']:
+        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' % (
-                    if phase in value and value[phase].get('weight', 0) < 4:
+            stime.year, stime.month, stime.day, stime.hour, stime.minute, stime.second,
-                        onset = value[phase]['mpp']
+            eventsource['latitude'], eventsource['longitude'], eventsource['depth'] / 1000,
-                        rt = (onset - stime).total_seconds()
+            eventinfo.magnitudes[0]['mag'], eventsource['quality']['standard_error'], hddID))
-                        fid.write('{}    {:6.3f}  1  {}\n'.format(key, rt, phase))
+        # 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]:
+                # 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))
 
-    def write_focmec():
+        fid.close()
-        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
-        with open(filename, 'w') as fid:
+        stime = eventsource['time']
-            origin = eventinfo.origins[0]
-            stime = origin.time
-            fid.write('{} {}{:02d}{:02d}{:02d}{:02d}{:02.0f} {:7.4f} {:6.4f} {:3.1f} {:3.1f}\n'.format(
-                parameter.get('eventid', 'e0000'), stime.year, stime.month, stime.day, stime.hour, stime.minute,
-                stime.second, origin.latitude, origin.longitude, origin.depth / 1000, eventinfo.magnitudes[0].mag))
-            for key, value in arrivals.items():
-                if 'P' in value and value['P'].get('weight', 0) < 4 and value['P'].get('fm'):
-                    for pick in eventinfo.picks:
-                        if pick.waveform_id.station_code == key:
-                            for arrival in origin.arrivals:
-                                if arrival.pick_id == pick.resource_id and arrival.phase == 'P':
-                                    stat = key[:4]
-                                    az = arrival.azimuth
-                                    inz = arrival.takeoff_angle
-                                    fid.write('{:<4}  {:6.2f}  {:6.2f}{}\n'.format(stat, az, inz, value['P']['fm']))
-                                    break
 
-    def write_hash():
+        # avoid printing '*' in focmec-input file
-        # Define filenames for HASH driver 1 and 2
+        if parameter.get('eventid') == '*' or parameter.get('eventid') is None:
-        filename1 = f"{filename}drv1.phase"
+            evID = 'e0000'
-        filename2 = f"{filename}drv2.phase"
+        else:
+            evID = parameter.get('eventid')
 
-        print(f"Writing phases to {filename1} for HASH-driver 1")
+        # write header line including event information
-        print(f"Writing phases to {filename2} for HASH-driver 2")
+        fid.write('%s %d%02d%02d%02d%02d%02.0f %7.4f %6.4f %3.1f %3.1f\n' % (evID,
-
+                                                                             stime.year, stime.month, stime.day,
-        # Open files for writing
+                                                                             stime.hour, stime.minute, stime.second,
-        with open(filename1, 'w') as fid1, open(filename2, 'w') as fid2:
+                                                                             eventsource['latitude'],
-            # Get event information needed for HASH-input file
+                                                                             eventsource['longitude'],
-            try:
+                                                                             eventsource['depth'] / 1000,
-                eventsource = eventinfo.origins[0]
+                                                                             eventinfo.magnitudes[0]['mag']))
-            except IndexError:
+        picks = eventinfo.picks
-                print("No source origin calculated yet, thus no cnv-file creation possible!")
+        # check whether arrivals are dictionaries (autoPyLoT) or pick object (PyLoT)
-                return
+        if isinstance(arrivals, dict) == False:
-
+            # convert pick object (PyLoT) into dictionary
-            event = parameter.get('eventID')
+            evt = ope.Event(resource_id=eventinfo['resource_id'])
-            hashID = event.split('.')[0][1:5]
+            evt.picks = arrivals
-            latdeg = eventsource['latitude']
+            arrivals = picksdict_from_picks(evt)
-            latmin = (eventsource['latitude'] * 60) / 10000
+        # check for automatic and manual picks
-            londeg = eventsource['longitude']
+        # prefer manual picks
-            lonmin = (eventsource['longitude'] * 60) / 10000
+        usedarrivals = chooseArrivals(arrivals)
-
+        for key in usedarrivals:
-            erh = (eventsource.origin_uncertainty['min_horizontal_uncertainty'] +
+            if 'P' in usedarrivals[key]:
-                   eventsource.origin_uncertainty['max_horizontal_uncertainty']) / 2000
+                if usedarrivals[key]['P']['weight'] < 4 and usedarrivals[key]['P']['fm'] is not None:
-            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']
+                    for i in range(len(picks)):
-                    ncode = arrival['P']['network']
+                        station = picks[i].waveform_id.station_code
-                    Pqual = 'I' if arrival['P']['weight'] < 2 else 'E'
+                        if station == stat:
-
+                            # get resource ID
-                    for pick in picks:
+                            resid_picks = picks[i].get('resource_id')
-                        if pick.waveform_id.station_code == stat:
+                            # find same ID in eventinfo
-                            resid_picks = pick.get('resource_id')
+                            # there it is the pick_id!!
-                            for origin_arrival in eventinfo.origins[0].arrivals:
+                            for j in range(len(eventinfo.origins[0].arrivals)):
-                                if (origin_arrival.get('pick_id') == resid_picks and
+                                resid_eventinfo = eventinfo.origins[0].arrivals[j].get('pick_id')
-                                        origin_arrival.phase == 'P'):
+                                if resid_eventinfo == resid_picks and eventinfo.origins[0].arrivals[j].phase == 'P':
-                                    if len(stat) > 4:  # HASH handles only 4-character station IDs
+                                    if len(stat) > 4:  # FOCMEC handles only 4-string station IDs
                                         stat = stat[1:5]
-
+                                    az = eventinfo.origins[0].arrivals[j].get('azimuth')
-                                    az = origin_arrival.get('azimuth')
+                                    inz = eventinfo.origins[0].arrivals[j].get('takeoff_angle')
-                                    inz = origin_arrival.get('takeoff_angle')
+                                    fid.write('%-4s  %6.2f  %6.2f%s \n' % (stat,
-                                    dist = origin_arrival.get('distance')
+                                                                           az,
-
+                                                                           inz,
-                                    # Write phase line for HASH-driver 1
+                                                                           usedarrivals[key]['P']['fm']))
-                                    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}")
+        fid.close()
 
-    # 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':
-        write_hash()
+        # two different input files for 
+        # 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):
@@ -670,7 +1122,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

@@ -1,177 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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 write_phases
+from pylot.core.io.phases import writephases
 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
-    write_phases(picks, 'FOCMEC', fnout, parameter, eventinfo)
+    writephases(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 write_phases
+from pylot.core.io.phases import writephases
 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
-    write_phases(picks, 'HASH', fnout, parameter, eventinfo)
+    writephases(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 write_phases
+from pylot.core.io.phases import writephases
 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
-    write_phases(picks, 'HYPO71', fnout, parameter)
+    writephases(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 write_phases
+from pylot.core.io.phases import writephases
 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
-    write_phases(picks, 'HYPODD', fnout, parameter, eventinfo)
+    writephases(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 write_phases
+from pylot.core.io.phases import writephases
 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
-    write_phases(picks, 'HYPOSAT', fnout, parameter)
+    writephases(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 write_phases
+from pylot.core.io.phases import writephases
 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
-    write_phases(picks, 'NLLoc', fnout, parameter)
+    writephases(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 write_phases
+from pylot.core.io.phases import writephases
 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
-    write_phases(picks, 'VELEST', fnout, parameter, eventinfo)
+    writephases(picks, 'VELEST', fnout, parameter, eventinfo)

pylot/core/util/array_map.py

@@ -5,12 +5,13 @@ import traceback
 
 import cartopy.crs as ccrs
 import cartopy.feature as cf
+from cartopy.mpl.ticker import LongitudeFormatter, LatitudeFormatter
 import matplotlib
 import matplotlib.patheffects as PathEffects
 import matplotlib.pyplot as plt
 import numpy as np
 import obspy
-from PySide2 import QtWidgets
+from PySide2 import QtWidgets, QtGui
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 from mpl_toolkits.axes_grid1.inset_locator import inset_axes
 from pylot.core.util.utils import identifyPhaseID
@@ -24,10 +25,10 @@ matplotlib.use('Qt5Agg')
 
 class MplCanvas(FigureCanvas):
 
-    def __init__(self, parent=None, extern_axes=None, width=5, height=4, dpi=100):
+    def __init__(self, extern_axes=None, projection=None, width=15, height=5, dpi=100):
         if extern_axes is None:
             self.fig = plt.figure(figsize=(width, height), dpi=dpi)
-            self.axes = self.fig.add_subplot(111)
+            self.axes = self.fig.add_subplot(111, projection=projection)
         else:
             self.fig = extern_axes.figure
             self.axes = extern_axes
@@ -63,20 +64,25 @@ class Array_map(QtWidgets.QWidget):
         self.highlighted_stations = []
 
         # call functions to draw everything
+        self.projection = ccrs.PlateCarree()
         self.init_graphics()
+        self.ax = self.canvas.axes
+        self.ax.set_adjustable('datalim')
+
         self.init_stations()
         self.init_crtpyMap()
         self.init_map()
+
         # set original map limits to fall back on when home button is pressed
-        self.org_xlim = self.canvas.axes.get_xlim()
+        self.org_xlim = self.ax.get_xlim()
-        self.org_ylim = self.canvas.axes.get_ylim()
+        self.org_ylim = self.ax.get_ylim()
+
         # initial map without event
-        self.canvas.axes.set_xlim(self.org_xlim[0], self.org_xlim[1])
+        self.ax.set_xlim(self.org_xlim[0], self.org_xlim[1])
-        self.canvas.axes.set_ylim(self.org_ylim[0], self.org_ylim[1])
+        self.ax.set_ylim(self.org_ylim[0], self.org_ylim[1])
 
         self._style = None if not hasattr(parent, '_style') else parent._style
 
-
     def init_map(self):
         self.init_colormap()
         self.connectSignals()
@@ -89,11 +95,11 @@ class Array_map(QtWidgets.QWidget):
         # initialize figure elements
 
         if self.extern_plot_axes is None:
-            self.canvas = MplCanvas(self)
+            self.canvas = MplCanvas(projection=self.projection)
-            self.plotWidget = FigureCanvas(self.canvas.fig)
         else:
-            self.canvas = MplCanvas(self, extern_axes=self.extern_plot_axes)
+            self.canvas = MplCanvas(extern_axes=self.extern_plot_axes)
-            self.plotWidget = FigureCanvas(self.canvas.fig)
+
+        self.plotWidget = self.canvas
 
         # initialize GUI elements
         self.status_label = QtWidgets.QLabel()
@@ -105,7 +111,7 @@ class Array_map(QtWidgets.QWidget):
         self.setLayout(self.main_box)
 
         self.top_row = QtWidgets.QHBoxLayout()
-        self.main_box.addLayout(self.top_row, 1)
+        self.main_box.addLayout(self.top_row, 0)
 
         self.comboBox_phase = QtWidgets.QComboBox()
         self.comboBox_phase.insertItem(0, 'P')
@@ -138,10 +144,10 @@ class Array_map(QtWidgets.QWidget):
         self.top_row.addWidget(self.auto_refresh_box)
         self.top_row.addWidget(self.refresh_button)
 
-        self.main_box.addWidget(self.plotWidget, 1)
+        self.main_box.addWidget(self.plotWidget, 10)
 
         self.bot_row = QtWidgets.QHBoxLayout()
-        self.main_box.addLayout(self.bot_row, 0.3)
+        self.main_box.addLayout(self.bot_row, 0)
         self.bot_row.addWidget(QtWidgets.QLabel(''), 5)
         self.bot_row.addWidget(self.map_reset_button, 2)
         self.bot_row.addWidget(self.go2eq_button, 2)
@@ -153,14 +159,12 @@ class Array_map(QtWidgets.QWidget):
         self.init_lat_lon_grid()
 
     def init_crtpyMap(self):
-        self.canvas.axes.cla()
+        self.ax.add_feature(cf.LAND)
-        self.canvas.axes = plt.axes(projection=ccrs.PlateCarree())
+        self.ax.add_feature(cf.OCEAN)
-        self.canvas.axes.add_feature(cf.LAND)
+        self.ax.add_feature(cf.COASTLINE, linewidth=1, edgecolor='gray')
-        self.canvas.axes.add_feature(cf.OCEAN)
+        self.ax.add_feature(cf.BORDERS, alpha=0.7)
-        self.canvas.axes.add_feature(cf.COASTLINE, linewidth=1, edgecolor='gray')
+        self.ax.add_feature(cf.LAKES, alpha=0.7)
-        self.canvas.axes.add_feature(cf.BORDERS, alpha=0.7)
+        self.ax.add_feature(cf.RIVERS, linewidth=1)
-        self.canvas.axes.add_feature(cf.LAKES, alpha=0.7)
-        self.canvas.axes.add_feature(cf.RIVERS, linewidth=1)
 
         # parallels and meridians
         self.add_merid_paral()
@@ -168,12 +172,8 @@ class Array_map(QtWidgets.QWidget):
         self.canvas.fig.tight_layout()
 
     def add_merid_paral(self):
-        self.gridlines = self.canvas.axes.gridlines(draw_labels=False, alpha=0.6, color='gray',
+        self.gridlines = self.ax.gridlines(draw_labels=False, alpha=0.6, color='gray',
-                                                    linewidth=self.linewidth / 2, zorder=7)
+                                           linewidth=self.linewidth / 2, zorder=7, crs=ccrs.PlateCarree())
-        # TODO: current cartopy version does not support label removal. Devs are working on it.
-        #  Should be fixed in coming cartopy versions
-        # self.gridlines.xformatter = LONGITUDE_FORMATTER
-        # self.gridlines.yformatter = LATITUDE_FORMATTER
 
     def remove_merid_paral(self):
         if len(self.gridlines.xline_artists):
@@ -181,24 +181,24 @@ class Array_map(QtWidgets.QWidget):
             self.gridlines.yline_artists[0].remove()
 
     def org_map_view(self):
-        self.canvas.axes.set_xlim(self.org_xlim[0], self.org_xlim[1])
+        self.ax.set_xlim(self.org_xlim[0], self.org_xlim[1])
-        self.canvas.axes.set_ylim(self.org_ylim[0], self.org_ylim[1])
+        self.ax.set_ylim(self.org_ylim[0], self.org_ylim[1])
         # parallels and meridians
-        self.remove_merid_paral()
+        #self.remove_merid_paral()
-        self.add_merid_paral()
+        #self.add_merid_paral()
 
-        self.canvas.axes.figure.canvas.draw_idle()
+        self.canvas.draw_idle()
 
     def go2eq(self):
         if self.eventLoc:
             lats, lons = self.eventLoc
-            self.canvas.axes.set_xlim(lons - 10, lons + 10)
+            self.ax.set_xlim(lons - 10, lons + 10)
-            self.canvas.axes.set_ylim(lats - 5, lats + 5)
+            self.ax.set_ylim(lats - 5, lats + 5)
             # parallels and meridians
-            self.remove_merid_paral()
+            #self.remove_merid_paral()
-            self.add_merid_paral()
+            #self.add_merid_paral()
 
-            self.canvas.axes.figure.canvas.draw_idle()
+            self.canvas.draw_idle()
 
         else:
             self.status_label.setText('No event information available')
@@ -220,21 +220,30 @@ class Array_map(QtWidgets.QWidget):
 
     # set mouse events -----------------------------------------------------
     def mouse_moved(self, event):
-        if not event.inaxes == self.canvas.axes:
+        if not event.inaxes == self.ax:
             return
+        else:
+            cont, inds = self.sc.contains(event)
         lat = event.ydata
         lon = event.xdata
-        self.status_label.setText('Latitude: {:3.5f}, Longitude: {:3.5f}'.format(lat, lon))
+        text = f'Longitude: {lon:3.3f}, Latitude: {lat:3.3f}'
+
+        if cont:
+            indices = inds['ind']
+            text += ' | Station: ' if len(indices) == 1 else ' | Stations: '
+            text += ' - '.join([self._station_onpick_ids[index] for index in indices])
+
+        self.status_label.setText(text)
 
     def mouse_scroll(self, event):
-        if not event.inaxes == self.canvas.axes:
+        if not event.inaxes == self.ax:
             return
 
         zoom = {'up': 1. / 2., 'down': 2.}
 
         if event.button in zoom:
-            xlim = self.canvas.axes.get_xlim()
+            xlim = self.ax.get_xlim()
-            ylim = self.canvas.axes.get_ylim()
+            ylim = self.ax.get_ylim()
 
             x, y = event.xdata, event.ydata
 
@@ -246,24 +255,24 @@ class Array_map(QtWidgets.QWidget):
             yb = y - 0.5 * ydiff
             yt = y + 0.5 * ydiff
 
-            self.canvas.axes.set_xlim(xl, xr)
+            self.ax.set_xlim(xl, xr)
-            self.canvas.axes.set_ylim(yb, yt)
+            self.ax.set_ylim(yb, yt)
             # parallels and meridians
-            self.remove_merid_paral()
+            #self.remove_merid_paral()
-            self.add_merid_paral()
+            #self.add_merid_paral()
 
-            self.canvas.axes.figure.canvas.draw_idle()
+            self.ax.figure.canvas.draw_idle()
 
     def mouseLeftPress(self, event):
-        if not event.inaxes == self.canvas.axes:
+        if not event.inaxes == self.ax:
             return
         self.map_x = event.xdata
         self.map_y = event.ydata
-        self.map_xlim = self.canvas.axes.get_xlim()
+        self.map_xlim = self.ax.get_xlim()
-        self.map_ylim = self.canvas.axes.get_ylim()
+        self.map_ylim = self.ax.get_ylim()
 
     def mouseLeftRelease(self, event):
-        if not event.inaxes == self.canvas.axes:
+        if not event.inaxes == self.ax:
             return
         new_x = event.xdata
         new_y = event.ydata
@@ -271,13 +280,13 @@ class Array_map(QtWidgets.QWidget):
         dx = new_x - self.map_x
         dy = new_y - self.map_y
 
-        self.canvas.axes.set_xlim((self.map_xlim[0] - dx, self.map_xlim[1] - dx))
+        self.ax.set_xlim((self.map_xlim[0] - dx, self.map_xlim[1] - dx))
-        self.canvas.axes.set_ylim(self.map_ylim[0] - dy, self.map_ylim[1] - dy)
+        self.ax.set_ylim(self.map_ylim[0] - dy, self.map_ylim[1] - dy)
         # parallels and meridians
-        self.remove_merid_paral()
+        #self.remove_merid_paral()
-        self.add_merid_paral()
+        #self.add_merid_paral()
 
-        self.canvas.axes.figure.canvas.draw_idle()
+        self.ax.figure.canvas.draw_idle()
 
     def onpick(self, event):
         btn_msg = {1: ' in selection. Aborted', 2: ' to delete a pick on. Aborted', 3: ' to display info.'}
@@ -469,13 +478,20 @@ class Array_map(QtWidgets.QWidget):
         stat_dict = self.stations_dict['{}.{}'.format(network, station)]
         lat = stat_dict['latitude']
         lon = stat_dict['longitude']
-        self.highlighted_stations.append(self.canvas.axes.scatter(lon, lat, s=self.pointsize, edgecolors=color,
+        self.highlighted_stations.append(self.ax.scatter(lon, lat, s=self.pointsize, edgecolors=color,
-                                                                  facecolors='none', zorder=12,
+                                                         facecolors='none', zorder=12,
-                                                                  transform=ccrs.PlateCarree(), label='deleted'))
+                                                         transform=ccrs.PlateCarree(), label='deleted'))
 
     def openPickDlg(self, ind):
-        wfdata = self._parent.get_data().get_wf_data()
+        try:
-        wfdata_comp = self._parent.get_data().get_wf_dataComp()
+            wfdata = self._parent.get_data().getWFData()
+        except AttributeError:
+            QtWidgets.QMessageBox.warning(
+                self, "PyLoT Warning",
+                "No waveform data found. Check if they were already loaded in Waveform plot tab."
+            )
+            return
+        wfdata_comp = self._parent.get_data().getAltWFdata()
         for index in ind:
             network, station = self._station_onpick_ids[index].split('.')[:2]
             pyl_mw = self._parent
@@ -521,9 +537,9 @@ class Array_map(QtWidgets.QWidget):
     def draw_contour_filled(self, nlevel=50):
         levels = np.linspace(self.get_min_from_picks(), self.get_max_from_picks(), nlevel)
 
-        self.contourf = self.canvas.axes.contourf(self.longrid, self.latgrid, self.picksgrid_active, levels,
+        self.contourf = self.ax.contourf(self.longrid, self.latgrid, self.picksgrid_active, levels,
-                                                  linewidths=self.linewidth * 5, transform=ccrs.PlateCarree(),
+                                         linewidths=self.linewidth * 5, transform=ccrs.PlateCarree(),
-                                                  alpha=0.4, zorder=8, cmap=self.get_colormap())
+                                         alpha=0.4, zorder=8, cmap=self.get_colormap())
 
     def get_colormap(self):
         return plt.get_cmap(self.cmaps_box.currentText())
@@ -531,18 +547,18 @@ class Array_map(QtWidgets.QWidget):
     def scatter_all_stations(self):
         stations, lats, lons = self.get_st_lat_lon_for_plot()
 
-        self.sc = self.canvas.axes.scatter(lons, lats, s=self.pointsize * 3, facecolor='none', marker='.',
+        self.sc = self.ax.scatter(lons, lats, s=self.pointsize * 3, facecolor='none', marker='.',
-                                           zorder=10, picker=True, edgecolor='0.5', label='Not Picked',
+                                  zorder=10, picker=True, edgecolor='0.5', label='Not Picked',
-                                           transform=ccrs.PlateCarree())
+                                  transform=ccrs.PlateCarree())
 
         self.cid = self.plotWidget.mpl_connect('pick_event', self.onpick)
         self._station_onpick_ids = stations
         if self.eventLoc:
             lats, lons = self.eventLoc
-            self.sc_event = self.canvas.axes.scatter(lons, lats, s=5 * self.pointsize, facecolor='red', zorder=11,
+            self.sc_event = self.ax.scatter(lons, lats, s=5 * self.pointsize, facecolor='red', zorder=11,
-                                                     label='Event (might be outside map region)', marker='*',
+                                            label='Event (might be outside map region)', marker='*',
-                                                     edgecolors='black',
+                                            edgecolors='black',
-                                                     transform=ccrs.PlateCarree())
+                                            transform=ccrs.PlateCarree())
 
     def scatter_picked_stations(self):
         picks, uncertainties, lats, lons = self.get_picks_lat_lon()
@@ -555,8 +571,8 @@ class Array_map(QtWidgets.QWidget):
                           for uncertainty in uncertainties])
 
         cmap = self.get_colormap()
-        self.sc_picked = self.canvas.axes.scatter(lons, lats, s=sizes, edgecolors='white', cmap=cmap,
+        self.sc_picked = self.ax.scatter(lons, lats, s=sizes, edgecolors='white', cmap=cmap,
-                                                  c=picks, zorder=11, label='Picked', transform=ccrs.PlateCarree())
+                                         c=picks, zorder=11, label='Picked', transform=ccrs.PlateCarree())
 
     def annotate_ax(self):
         self.annotations = []
@@ -574,20 +590,20 @@ class Array_map(QtWidgets.QWidget):
             if st in self.marked_stations:
                 color = 'red'
             self.annotations.append(
-                self.canvas.axes.annotate(' %s' % st, xy=(x + 0.003, y + 0.003), fontsize=self.pointsize / 4.,
+                self.ax.annotate(f'{st}', xy=(x + 0.003, y + 0.003), fontsize=self.pointsize / 4.,
-                                          fontweight='semibold', color=color, alpha=0.8,
+                                 fontweight='semibold', color=color, alpha=0.8,
-                                          transform=ccrs.PlateCarree(), zorder=14,
+                                 transform=ccrs.PlateCarree(), zorder=14,
-                                          path_effects=[PathEffects.withStroke(
+                                 path_effects=[PathEffects.withStroke(
-                                              linewidth=self.pointsize / 15., foreground='k')]))
+                                     linewidth=self.pointsize / 15., foreground='k')]))
 
-        self.legend = self.canvas.axes.legend(loc=1, framealpha=1)
+        self.legend = self.ax.legend(loc=1, framealpha=1)
         self.legend.set_zorder(100)
         self.legend.get_frame().set_facecolor((1, 1, 1, 0.95))
 
     def add_cbar(self, label):
-        self.cbax_bg = inset_axes(self.canvas.axes, width="6%", height="75%", loc=5)
+        self.cbax_bg = inset_axes(self.ax, width="6%", height="75%", loc=5)
-        cbax = inset_axes(self.canvas.axes, width='2%', height='70%', loc=5)
+        cbax = inset_axes(self.ax, width='2%', height='70%', loc=5)
-        cbar = self.canvas.axes.figure.colorbar(self.sc_picked, cax=cbax)
+        cbar = self.ax.figure.colorbar(self.sc_picked, cax=cbax)
         cbar.set_label(label)
         cbax.yaxis.tick_left()
         cbax.yaxis.set_label_position('left')

pylot/core/util/dataprocessing.py

@@ -338,6 +338,19 @@ 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
@@ -375,6 +388,167 @@ 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.core.io.project import Project
+from PyLoT 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
+from pylot.core.io.data import SeiscompDataStructure, PilotDataStructure, ObspyDMTdataStructure
 
 DATASTRUCTURE = {'PILOT': PilotDataStructure, 'SeisComP': SeiscompDataStructure,
-                 'obspyDMT': PilotDataStructure, None: PilotDataStructure}
+                 'obspyDMT': ObspyDMTdataStructure, None: PilotDataStructure}

pylot/core/util/utils.py

@@ -8,6 +8,7 @@ import platform
 import re
 import subprocess
 import warnings
+from typing import Literal, Tuple, Type
 from functools import lru_cache
 
 import numpy as np
@@ -106,7 +107,7 @@ def gen_Pool(ncores=0):
 
     print('gen_Pool: Generated multiprocessing Pool with {} cores\n'.format(ncores))
 
-    pool = multiprocessing.Pool(ncores)
+    pool = multiprocessing.Pool(ncores, maxtasksperchild=100)
     return pool
 
 
@@ -357,10 +358,8 @@ def get_bool(value):
     False
     >>> get_bool(None)
     None
-    >>> get_bool('Stream')
-    'Stream'
     """
-    if type(value) == bool:
+    if type(value) is bool:
         return value
     elif value in ['True', 'true']:
         return True
@@ -901,19 +900,6 @@ def trim_station_components(data, trim_start=True, trim_end=True):
     return data
 
 
-def merge_stream(stream):
-    gaps = stream.get_gaps()
-    if gaps:
-        # list of merged stations (seed_ids)
-        merged = ['{}.{}.{}.{}'.format(*gap[:4]) for gap in gaps]
-        stream.merge(method=1)
-        print('Merged the following stations because of gaps:')
-        for merged_station in merged:
-            print(merged_station)
-
-    return stream, gaps
-
-
 def check4gapsAndRemove(data):
     """
     check for gaps in Stream and remove them
@@ -934,12 +920,12 @@ def check4gapsAndRemove(data):
     return data
 
 
-def check4gapsAndMerge(data):
+def check_for_gaps_and_merge(data):
     """
     check for gaps in Stream and merge if gaps are found
     :param data: stream of seismic data
     :type data: `~obspy.core.stream.Stream`
-    :return: data stream
+    :return: data stream, gaps returned from obspy get_gaps
     :rtype: `~obspy.core.stream.Stream`
     """
     gaps = data.get_gaps()
@@ -950,7 +936,7 @@ def check4gapsAndMerge(data):
         for merged_station in merged:
             print(merged_station)
 
-    return data
+    return data, gaps
 
 
 def check4doubled(data):
@@ -1098,8 +1084,9 @@ def check4rotated(data, metadata=None, verbosity=1):
                 azimuths.append(metadata.get_coordinates(tr_id, t_start)['azimuth'])
                 dips.append(metadata.get_coordinates(tr_id, t_start)['dip'])
         except (KeyError, TypeError) as err:
-            logging.error(f"{type(err)=} occurred: {err=} Rotating not possible, not all azimuth and dip information "
+            logging.warning(f"Rotating not possible, not all azimuth and dip information "
-                  f"available in metadata. Stream remains unchanged.")
+                            f"available in metadata. Stream remains unchanged.")
+            logging.debug(f"Rotating not possible, {err=}, {type(err)=}")
             return wfs_in
         except Exception as err:
             print(f"Unexpected {err=}, {type(err)=}")
@@ -1218,6 +1205,7 @@ def identifyPhase(phase):
         return False
 
 
+@lru_cache
 def identifyPhaseID(phase):
     """
     Returns phase id (capital P or S)

pylot/core/util/widgets.py

@@ -140,6 +140,18 @@ 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
@@ -997,6 +1009,15 @@ 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)
@@ -1150,6 +1171,8 @@ 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
@@ -1357,140 +1380,125 @@ class PylotCanvas(FigureCanvas):
                    component='*', nth_sample=1, iniPick=None, verbosity=0,
                    plot_additional=False, additional_channel=None, scaleToChannel=None,
                    snr=None):
-        ax = self.prepare_plot()
+        def get_wf_dict(data: Stream = Stream(), linecolor = 'k', offset: float = 0., **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
-
-    def get_wf_range(self, wfdata):
-        return full_range(wfdata)
-
-    def get_comp_class(self):
-        settings = QSettings()
-        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)
-        }
 
-        if component != '*':
+        ax = self.axes[0]
+        ax.cla()
+
+        self.clearPlotDict()
+        wfstart, wfend = full_range(wfdata)
+        nmax = 0
+
+        settings = QSettings()
+        compclass = SetChannelComponents.from_qsettings(settings)
+
+        linecolor = (0., 0., 0., 1.) if not self.style else self.style['linecolor']['rgba_mpl']
+
+        plot_streams = dict(wfdata=get_wf_dict(linecolor=linecolor, linewidth=0.7),
+                            wfdata_comp=get_wf_dict(offset=0.1, linecolor='b', alpha=0.7, linewidth=0.5))
+
+        if not component == '*':
             alter_comp = compclass.getCompPosition(component)
-            plot_streams['wfdata']['data'] = wfdata.select(component=component) + wfdata.select(component=alter_comp)
+            # alter_comp = str(alter_comp[0])
+
+            plot_streams['wfdata']['data'] = wfdata.select(component=component)
+            plot_streams['wfdata']['data'] += wfdata.select(component=alter_comp)
             if wfdata_compare:
-                plot_streams['wfdata_comp']['data'] = wfdata_compare.select(
+                plot_streams['wfdata_comp']['data'] = wfdata_compare.select(component=component)
-                    component=component) + wfdata_compare.select(component=alter_comp)
+                plot_streams['wfdata_comp']['data'] += wfdata_compare.select(component=alter_comp)
         else:
             plot_streams['wfdata']['data'] = wfdata
             if wfdata_compare:
                 plot_streams['wfdata_comp']['data'] = wfdata_compare
 
-        return plot_streams
+        st_main = plot_streams['wfdata']['data']
 
-    def get_sorted_nslc(self, st_main):
+        if mapping:
-        nslc = [trace.get_id() for trace in st_main if trace.stats.channel[-1] in ['Z', 'N', 'E', '1', '2', '3']]
+            plot_positions = self.calcPlotPositions(st_main, compclass)
-        nslc.sort(reverse=True)
+
-        return nslc
+        # list containing tuples of network, station, channel and plot position (for sorting)
+        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
-                trace = st_select.select(id=seed_id)[0].copy()
+                st = st_select.select(id=seed_id)
+                trace = st[0].copy()
                 if mapping:
                     n = plot_positions[trace.stats.channel]
                 if n > nmax:
                     nmax = n
                 if verbosity:
-                    print(f'plotting {channel} channel of station {station}')
+                    msg = 'plotting %s channel of station %s' % (channel, station)
-                time_ax = prep_time_axis(trace.stats.starttime - wfstart, trace)
+                    print(msg)
-                self.plot_trace(ax, trace, time_ax, wf_dict, n, scaleToChannel, noiselevel, scaleddata, nth_sample)
+                stime = trace.stats.starttime - wfstart
-                self.setPlotDict(n, seed_id)
+                time_ax = prep_time_axis(stime, trace)
-        return nmax
+                if time_ax is not None:
+                    if scaleToChannel:
+                        st_scale = wfdata.select(channel=scaleToChannel)
+                        if st_scale:
+                            tr = st_scale[0]
+                            trace.detrend('constant')
+                            trace.normalize(np.max(np.abs(tr.data)) * 2)
+                            scaleddata = True
+                    if not scaleddata:
+                        trace.detrend('constant')
+                        trace.normalize(np.max(np.abs(trace.data)) * 2)
 
-    def plot_trace(self, ax, trace, time_ax, wf_dict, n, scaleToChannel, noiselevel, scaleddata, nth_sample):
+                    offset = wf_dict.get('offset')
-        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:
-                self.plot_noise_level(ax, time_ax, noiselevel, channel, n, wf_dict.get('linecolor'))
+                        for level in [-noiselevel[channel], noiselevel[channel]]:
+                            ax.plot([time_ax[0], time_ax[-1]],
+                                    [n + level, n + level],
+                                    color=wf_dict.get('linecolor'),
+                                    linestyle='dashed')
+                    self.setPlotDict(n, seed_id)
+        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], colors='m', linestyles='dashed', linewidth=2)
+            ax.vlines(iniPick, ax.get_ylim()[0], ax.get_ylim()[1],
-        xlabel = f'seconds since {wfstart}'
+                      colors='m', linestyles='dashed',
+                      linewidth=2)
+        xlabel = 'seconds since {0}'.format(wfstart)
         ylabel = ''
         self.updateWidget(xlabel, ylabel, title)
         self.setXLims(ax, [0, wfend - wfstart])
@@ -1500,13 +1508,14 @@ class PylotCanvas(FigureCanvas):
         if zoomy is not None:
             self.setYLims(ax, zoomy)
         if snr is not None:
-            self.plot_snr_warning(ax, snr)
+            if snr < 2:
-        self.draw()
+                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')
 
-    def plot_snr_warning(self, ax, snr):
+        self.draw()
-        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):
@@ -1912,7 +1921,7 @@ class PickDlg(QDialog):
         # set attribute holding data
         if data is None or not data:
             try:
-                data = parent.get_data().get_wf_data().copy()
+                data = parent.get_data().getWFData().copy()
                 self.data = data.select(station=station)
             except AttributeError as e:
                 errmsg = 'You either have to put in a data or an appropriate ' \
@@ -1946,7 +1955,7 @@ class PickDlg(QDialog):
         self.cur_xlim = None
         self.cur_ylim = None
 
-        self.stime, self.etime = full_range(self.get_wf_data())
+        self.stime, self.etime = full_range(self.getWFData())
 
         # initialize plotting widget
         self.multicompfig = PylotCanvas(parent=self, multicursor=True)
@@ -1960,7 +1969,7 @@ class PickDlg(QDialog):
         self.referenceChannel.addItem('-', None)
         self.scaleChannel.addItem('individual', None)
 
-        for trace in self.get_wf_data():
+        for trace in self.getWFData():
             channel = trace.stats.channel
             self.referenceChannel.addItem(channel, trace)
             if not channel[-1] in ['Z', 'N', 'E', '1', '2', '3']:
@@ -1979,7 +1988,7 @@ class PickDlg(QDialog):
         if self.wftype is not None:
             title += ' | ({})'.format(self.wftype)
 
-        self.multicompfig.plotWFData(wfdata=self.get_wf_data(), wfdata_compare=self.get_wf_dataComp(),
+        self.multicompfig.plotWFData(wfdata=self.getWFData(), wfdata_compare=self.getWFDataComp(),
                                      title=title)
 
         self.multicompfig.setZoomBorders2content()
@@ -2514,7 +2523,7 @@ class PickDlg(QDialog):
         if self.autoFilterAction.isChecked():
             for filteraction in [self.filterActionP, self.filterActionS]:
                 filteraction.setChecked(False)
-            self.filter_wf_data()
+            self.filterWFData()
             self.draw()
         else:
             self.draw()
@@ -2598,10 +2607,10 @@ class PickDlg(QDialog):
     def getGlobalLimits(self, ax, axis):
         return self.multicompfig.getGlobalLimits(ax, axis)
 
-    def get_wf_data(self):
+    def getWFData(self):
         return self.data
 
-    def get_wf_dataComp(self):
+    def getWFDataComp(self):
         if self.showCompData:
             return self.data_compare
         else:
@@ -2616,17 +2625,17 @@ class PickDlg(QDialog):
                 return tr
 
         if component == 'E' or component == 'N':
-            for trace in self.get_wf_data():
+            for trace in self.getWFData():
                 trace = selectTrace(trace, 'NE')
                 if trace:
                     wfdata.append(trace)
         elif component == '1' or component == '2':
-            for trace in self.get_wf_data():
+            for trace in self.getWFData():
                 trace = selectTrace(trace, '12')
                 if trace:
                     wfdata.append(trace)
         else:
-            wfdata = self.get_wf_data().select(component=component)
+            wfdata = self.getWFData().select(component=component)
         return wfdata
 
     def getPicks(self, picktype='manual'):
@@ -2729,8 +2738,8 @@ class PickDlg(QDialog):
         stime = self.getStartTime()
 
         # copy wfdata for plotting
-        wfdata = self.get_wf_data().copy()
+        wfdata = self.getWFData().copy()
-        wfdata_comp = self.get_wf_dataComp().copy()
+        wfdata_comp = self.getWFDataComp().copy()
         wfdata = self.getPickPhases(wfdata, phase)
         wfdata_comp = self.getPickPhases(wfdata_comp, phase)
         for wfd in [wfdata, wfdata_comp]:
@@ -2839,7 +2848,7 @@ class PickDlg(QDialog):
             filteroptions = None
 
         # copy and filter data for earliest and latest possible picks
-        wfdata = self.get_wf_data().copy().select(channel=channel)
+        wfdata = self.getWFData().copy().select(channel=channel)
         if filteroptions:
             try:
                 wfdata.detrend('linear')
@@ -2886,7 +2895,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.get_wf_data().select(channel=channel).copy(), wfdata.copy(), parameter.get('fmpickwin'),
+                FM = fmpicker(self.getWFData().select(channel=channel).copy(), wfdata.copy(), parameter.get('fmpickwin'),
                               pick - stime_diff)
 
         # save pick times for actual phase
@@ -3178,7 +3187,7 @@ class PickDlg(QDialog):
     def togglePickBlocker(self):
         return not self.pick_block
 
-    def filter_wf_data(self, phase=None):
+    def filterWFData(self, phase=None):
         if not phase:
             phase = self.currentPhase
             if self.getPhaseID(phase) == 'P':
@@ -3196,8 +3205,8 @@ class PickDlg(QDialog):
         self.cur_xlim = self.multicompfig.axes[0].get_xlim()
         self.cur_ylim = self.multicompfig.axes[0].get_ylim()
         # self.multicompfig.updateCurrentLimits()
-        wfdata = self.get_wf_data().copy()
+        wfdata = self.getWFData().copy()
-        wfdata_comp = self.get_wf_dataComp().copy()
+        wfdata_comp = self.getWFDataComp().copy()
         title = self.getStation()
         if filter:
             filtoptions = None
@@ -3234,14 +3243,14 @@ class PickDlg(QDialog):
     def filterP(self):
         self.filterActionS.setChecked(False)
         if self.filterActionP.isChecked():
-            self.filter_wf_data('P')
+            self.filterWFData('P')
         else:
             self.refreshPlot()
 
     def filterS(self):
         self.filterActionP.setChecked(False)
         if self.filterActionS.isChecked():
-            self.filter_wf_data('S')
+            self.filterWFData('S')
         else:
             self.refreshPlot()
 
@@ -3300,7 +3309,7 @@ class PickDlg(QDialog):
         if self.autoFilterAction.isChecked():
             self.filterActionP.setChecked(False)
             self.filterActionS.setChecked(False)
-        # data = self.get_wf_data().copy()
+        # data = self.getWFData().copy()
         # title = self.getStation()
         filter = False
         phase = None
@@ -3800,8 +3809,8 @@ class TuneAutopicker(QWidget):
         fnames = self.station_ids[self.get_current_station_id()]
         if not fnames == self.fnames:
             self.fnames = fnames
-            self.data.set_wf_data(fnames)
+            self.data.setWFData(fnames)
-            wfdat = self.data.get_wf_data()  # all available streams
+            wfdat = self.data.getWFData()  # all available streams
             # remove possible underscores in station names
             # wfdat = remove_underscores(wfdat)
             # rotate misaligned stations to ZNE
@@ -3906,8 +3915,8 @@ class TuneAutopicker(QWidget):
             network = None
             location = None
 
-        wfdata = self.data.get_wf_data()
+        wfdata = self.data.getWFData()
-        wfdata_comp = self.data.get_wf_dataComp()
+        wfdata_comp = self.data.getWFDataComp()
         metadata = self.parent().metadata
         event = self.get_current_event()
         filteroptions = self.parent().filteroptions
@@ -3962,7 +3971,7 @@ class TuneAutopicker(QWidget):
         for plotitem in self._manual_pick_plots:
             self.clear_plotitem(plotitem)
         self._manual_pick_plots = []
-        st = self.data.get_wf_data()
+        st = self.data.getWFData()
         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

requirements.txt

@@ -1,9 +1,7 @@
-# This file may be used to create an environment using:
+Cartopy==0.23.0
-# $ conda create --name <env> --file <this file>
+joblib==1.4.2
-# platform: win-64
+obspy==1.4.1
-cartopy>=0.20.2
+pyaml==24.7.0
-numpy<2
+pyqtgraph==0.13.7
-obspy>=1.3.0
+PySide2==5.15.8
-pyqtgraph>=0.12.4
+pytest==8.3.2
-pyside2>=5.13.2
-scipy>=1.8.0