[refs #195] realized an object oriented implementation of comparison

comparing pdf represented picks should be easy, thus objects returning everything needed are implemented; histograms and other plots are planned next

pylot/core/pick/compare.py

@@ -1,6 +1,8 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
+import copy
+
 from obspy import read_events
 
 from pylot.core.read.io import picks_from_evt
@@ -11,27 +13,46 @@ __version__ = _getVersionString()
 __author__ = 'sebastianw'
 
 
-def read_data(fn, type='exp'):
+class Comparison(object):
     """
-    Reads pick data from QuakeML files named FN and returns a dictionary
+    A Comparison object contains information on the evaluated picks' probability
-    containing a ProbabilityDensityFunction object for each pick.
+    density function and compares these in terms of building the difference of
-    :param fn: name of the QuakeML file which contains the picks
+    compared pick sets. The results can be displayed as histograms showing its
-    :type fn: str
+    properties.
-    :return: a dictionary containing the picks represented as pdfs
     """
-    pdf_picks = picks_from_evt(read_events(fn)[0])
+    def __init__(self, **kwargs):
+        names = list()
+        self._pdfs = dict()
+        for name, fn in kwargs:
+            self._pdfs[name] = PDFDictionary.from_quakeml(fn)
+            names.append(name)
+        if len(names) > 2:
+            raise ValueError('Comparison is only defined for two '
+                                 'arguments!')
+        self._names = names
 
-    for station, phases in pdf_picks.items():
+    def __nonzero__(self):
-        for phase, values in phases.items():
+        if not len(self.names) == 2 or not self._pdfs:
-            phases[phase] = ProbabilityDensityFunction.fromPick(values['epp'],
+            return False
-                                                                values['mpp'],
+        return True
-                                                                values['lpp'],
-                                                                type=type)
 
-    return pdf_picks
+    def get(self, name):
+        return self._pdfs[name]
 
+    @property
+    def names(self):
+        return self._names
 
-def compare_picksets(a, b):
+    @names.setter
+    def names(self, names):
+        assert isinstance(names, list) and len(names) == 2, 'variable "names"' \
+                                                            ' is either not a' \
+                                                            ' list or its ' \
+                                                            'length is not 2:' \
+                                                            'names : {names}'.format(names=names)
+        self._names = names
+
+    def compare_picksets(self):
         """
         Compare two picksets A and B and return a dictionary compiling the results.
         Comparison is carried out with the help of pdf representation of the picks
@@ -44,18 +65,72 @@ def compare_picksets(a, b):
         :return: dictionary containing the resulting comparison pdfs for all picks
         :rtype: dict
         """
-    pdf_a = read_data(a)
-    pdf_b = read_data(b)
-
         compare_pdfs = dict()
 
+        pdf_a = self.get(self.names[0])
+        pdf_b = self.get(self.names[1])
+
         for station, phases in pdf_a.items():
             if station in pdf_b.keys():
                 compare_pdf = dict()
                 for phase in phases:
                     if phase in pdf_b[station].keys():
-                    compare_pdf[phase] = phases[phase] - pdf_b[station][phase]
+                        compare_pdf[phase] = phases[phase] - pdf_b[station][
+                            phase]
                 if compare_pdf is not None:
                     compare_pdfs[station] = compare_pdf
 
         return compare_pdfs
+
+
+class PDFDictionary(object):
+    """
+    A PDFDictionary is a dictionary like object containing structured data on
+    the probability density function of seismic phase onsets.
+    """
+    def __init__(self, data):
+        self._pickdata = data
+
+    def __nonzero__(self):
+        if len(self.pick_data) < 1:
+            return False
+        else:
+            return True
+
+    @property
+    def pick_data(self):
+        return self._pickdata
+
+    @pick_data.setter
+    def pick_data(self, data):
+        self._pickdata = data
+
+    @classmethod
+    def from_quakeml(self, fn):
+        cat = read_events(fn)
+        if len(cat) > 1:
+            raise NotImplementedError('reading more than one event at the same '
+                                      'time is not implemented yet! Sorry!')
+        self.pick_data = picks_from_evt(cat[0])
+
+    def pdf_data(self, type='exp'):
+        """
+        Returns probabiliy density function dictionary containing the
+        representation of the actual pick_data.
+        :param type: type of the returned
+         `~pylot.core.util.pdf.ProbabilityDensityFunction` object
+        :type type: str
+        :return: a dictionary containing the picks represented as pdfs
+        """
+
+        pdf_picks = copy.deepcopy(self.pick_data)
+
+        for station, phases in pdf_picks.items():
+            for phase, values in phases.items():
+                phases[phase] = ProbabilityDensityFunction.fromPick(values['epp'],
+                                                                    values['mpp'],
+                                                                    values['lpp'],
+                                                                    type=type)
+
+        return pdf_picks
+