refine code

Author: wjlei1990

pypaw/bins/filter_windows.py

@@ -16,6 +16,7 @@
 from __future__ import (absolute_import, division, print_function)
 import os
 import argparse
+from pprint import pprint
 from pytomo3d.window.filter_windows import filter_windows, count_windows
 from .utils import load_json, dump_json, load_yaml
 
@@ -35,6 +36,9 @@ def check_path(paths):
     if not check_keys(paths, keys):
         raise ValueError("Path file is bad!")
 
+    print("=" * 10 + " Path info " + "=" * 10)
+    pprint(paths)
+
 
 def check_param(params):
     keys = ["sensor", "measurement"]
@@ -49,6 +53,9 @@ def check_param(params):
     if not check_keys(params["measurement"], keys):
         raise ValueError("Param['measurement'] is bad!")
 
+    print("=" * 10 + " Path info " + "=" * 10)
+    pprint(params)
+
 
 def run_window_filter(paths, params, verbose=False):
     check_path(paths)
@@ -59,12 +66,8 @@ def run_window_filter(paths, params, verbose=False):
     output_file = paths["output_file"]
     measurement_file = paths["measurement_file"]
 
-    print("window file: %s" % window_file)
-    print("station_file: %s" % station_file)
-    print("measurement_file: %s" % measurement_file)
-    print("output filtered window file: %s" % output_file)
-
     windows = load_json(window_file)
+    # count the number of windows in the original window file
     nchans_old, nwins_old = count_windows(windows)
     stations = load_json(station_file)
     measurements = load_json(measurement_file)
@@ -74,17 +77,18 @@ def run_window_filter(paths, params, verbose=False):
         windows, stations, measurements, params, verbose=verbose)
 
     nchans_new, nwins_new = count_windows(windows_new)
+
     # dump the new windows file to replace the original one
     dump_json(windows_new, output_file)
 
     # dump the log file
     logfile = os.path.join(os.path.dirname(output_file), "filter.log")
-    print("Log file located at: %s" % logfile)
     dump_json(log, logfile)
 
     print("=" * 10 + " Summary " + "=" * 10)
     print("channels: %d --> %d" % (nchans_old, nchans_new))
     print("windows: %d -- > %d" % (nwins_old, nwins_new))
+    print("Log file located at: %s" % logfile)
 
 
 def main():

pypaw/sum_adjoint.py

@@ -15,18 +15,12 @@
 from __future__ import print_function, division, absolute_import
 import os
 from pprint import pprint
-import yaml
 from pyasdf import ASDFDataSet
-from pypaw.bins import load_json, dump_json
 from pytomo3d.adjoint.sum_adjoint import load_to_adjsrc, dump_adjsrc, \
     check_events_consistent, \
     create_weighted_adj, sum_adj_to_base, check_station_consistent, \
     rotate_adjoint_sources
-
-
-def load_yaml(fn):
-    with open(fn) as fh:
-        return yaml.load(fh)
+from .utils import read_json_file, dump_json, read_yaml_file
 
 
 def validate_path(path):
@@ -72,6 +66,10 @@ def validate_param(param):
 
 
 def save_adjoint_to_asdf(outputfile, events, adjoint_sources, stations):
+    """
+    Save events(obspy.Catalog) and adjoint sources, together with
+    staiton information, to asdf file on disk.
+    """
     print("="*15 + "\nWrite to file: %s" % outputfile)
     outputdir = os.path.dirname(outputfile)
     if not os.path.exists(outputdir):
@@ -211,7 +209,7 @@ def sum_asdf(self):
             filename = _file_info["asdf_file"]
             ds = ASDFDataSet(filename, mode='r')
             weight_file = _file_info["weight_file"]
-            weights = load_json(weight_file)
+            weights = read_json_file(weight_file)
             print("-" * 20)
             print("Adding asdf file(%s) using assigned weight_file(%s)"
                   % (filename, weight_file))
@@ -239,7 +237,7 @@ def dump_to_asdf(self, outputfile):
 
     def _parse_path(self):
         if isinstance(self.path, str):
-            path = load_json(self.path)
+            path = read_json_file(self.path)
         elif isinstance(self.path, dict):
             path = self.path
         else:
@@ -248,7 +246,7 @@ def _parse_path(self):
 
     def _parse_param(self):
         if isinstance(self.param, str):
-            param = load_yaml(self.param)
+            param = read_yaml_file(self.param)
         elif isinstance(self.param, dict):
             param = self.param
         else:

pypaw/utils.py

@@ -52,7 +52,7 @@ def __init__(self, d):
         self.__dict__ = d
 
 
-def read_json_file(parfile, obj_hook=True):
+def read_json_file(parfile, obj_hook=False):
     """
     Hook json to an JSONObject instance
     """

pypaw/window_weights.py

@@ -147,27 +147,28 @@ def extract_source_location(input_info):
     return src_info
 
 
-def check_cat_consistency(cat_ratio, cat_wcounts):
-    err = 0
-    # check consistency
-    for p, pinfo in cat_ratio:
-        for c in pinfo:
-            try:
-                cat_wcounts[p][c]
-            except KeyError:
-                err = 1
-                print("Missing %s.%s" % (p, c))
-    if err:
-        raise ValueError("category weighting ratio information is not "
-                         "consistent with window information")
-
-
 def plot_histogram(figname, array, nbins=50):
     # plot histogram of weights
     plt.hist(array, nbins)
     plt.savefig(figname)
 
 
+def analyze_category_weights(cat_weights, logfile):
+    log = {"category_weights": cat_weights}
+    maxw = 0
+    minw = 10**9
+    for _p, _pw in cat_weights.iteritems():
+        for _comp, _compw in _pw.iteritems():
+            if _compw > maxw:
+                maxw = _compw
+            if _compw < minw:
+                minw = _compw
+    log["summary"] = {"maxw": maxw, "minw": minw,
+                      "cond_num": maxw/minw}
+
+    dump_json(log, logfile)
+
+
 def validate_overall_weights(weights_array, nwins_array):
     """
     Validate the overall weights.
@@ -238,7 +239,7 @@ def __init__(self, path, param):
         self.cat_wcounts = {}
         self.cat_weights = None
 
-    def analyze_receiver(self, logfile):
+    def analyze_receiver_weights(self, logfile):
         log = {}
         for _p, _pw in self.weights.iteritems():
             log[_p] = {}
@@ -259,21 +260,6 @@ def analyze_receiver(self, logfile):
 
         dump_json(log, logfile)
 
-    def analyze_category(self, logfile):
-        log = {"category_weights": self.cat_weights}
-        maxw = 0
-        minw = 10**9
-        for _p, _pw in self.cat_weights.iteritems():
-            for _comp, _compw in _pw.iteritems():
-                if _compw > maxw:
-                    maxw = _compw
-                if _compw < minw:
-                    minw = _compw
-        log["summary"] = {"maxw": maxw, "minw": minw,
-                          "cond_num": maxw/minw}
-
-        dump_json(log, logfile)
-
     def analyze(self):
         """
         Analyze the final weight and generate log file
@@ -282,11 +268,11 @@ def analyze(self):
         logdir = os.path.dirname(self.path["logfile"])
         logfile = os.path.join(logdir, "log.receiver_weights.json")
         logger.info("receiver log file: %s" % logfile)
-        self.analyze_receiver(logfile)
+        self.analyze_receiver_weights(logfile)
 
         logfile = os.path.join(logdir, "log.category_weights.json")
         logger.info("category log file: %s" % logfile)
-        self.analyze_category(logfile)
+        analyze_category_weights(self.cat_weights, logfile)
 
         analyze_overall_weights(self.weights, self.rec_wcounts, logdir)
 
@@ -304,10 +290,10 @@ def calculate_receiver_weights_asdf(self):
         and normalized)separately.
         """
         logger_block("Receiver Weighting")
-        input_info = self.path["input"]
 
         weighting_param = self.param["receiver_weighting"]
 
+        input_info = self.path["input"]
         nperiods = len(input_info)
         period_idx = 0
         # determine receiver weightings for each asdf file
@@ -335,6 +321,7 @@ def smart_run(self):
         # calculate receiver weights
         self.calculate_receiver_weights_asdf()
         # calculate category weights
+        logger_block("Category Weighting")
         self.cat_weights = calculate_category_weights_interface(
             self.param["category_weighting"], self.cat_wcounts)