mt-metadata 0.3.9__py2.py3-none-any.whl → 0.4.0__py2.py3-none-any.whl

mt_metadata/timeseries/filters/channel_response.py

@@ -9,6 +9,7 @@ the frequency domain.
 .. note:: Time Delay filters should be applied in the time domain
     otherwise bad things can happen.
 """
+
 # =============================================================================
 # Imports
 # =============================================================================
@@ -16,6 +17,7 @@ from copy import deepcopy
 import numpy as np
 
 from mt_metadata.base import Base, get_schema
+from mt_metadata.base.helpers import requires
 from mt_metadata.timeseries.filters.standards import SCHEMA_FN_PATHS
 from mt_metadata.timeseries.filters import (
     PoleZeroFilter,
@@ -24,10 +26,14 @@ from mt_metadata.timeseries.filters import (
     FrequencyResponseTableFilter,
     FIRFilter,
 )
-from mt_metadata.timeseries.filters.filter_base import FilterBase
+
 from mt_metadata.utils.units import get_unit_object
 from mt_metadata.timeseries.filters.plotting_helpers import plot_response
-from obspy.core import inventory
+
+try:
+    from obspy.core import inventory
+except ImportError:
+    inventory = None
 
 # =============================================================================
 attr_dict = get_schema("channel_response", SCHEMA_FN_PATHS)
@@ -63,7 +69,6 @@ class ChannelResponse(Base):
     def __repr__(self):
         return self.__str__()
 
-
     @property
     def filters_list(self):
         """filters list"""
@@ -96,7 +101,9 @@ class ChannelResponse(Base):
         elif isinstance(value, (list, tuple, np.ndarray)):
             self._frequencies = np.array(value, dtype=float)
         else:
-            msg = f"input values must be an list, tuple, or np.ndarray, not {type(value)}"
+            msg = (
+                f"input values must be an list, tuple, or np.ndarray, not {type(value)}"
+            )
             self.logger.error(msg)
             raise TypeError(msg)
 
@@ -146,9 +153,7 @@ class ChannelResponse(Base):
             if is_supported_filter(item):
                 return_list.append(item)
             else:
-                fails.append(
-                    f"Item is not a supported filter type, {type(item)}"
-                )
+                fails.append(f"Item is not a supported filter type, {type(item)}")
 
         if fails:
             raise TypeError(", ".join(fails))
@@ -179,7 +184,7 @@ class ChannelResponse(Base):
     def normalization_frequency(self):
         """get normalization frequency from ZPK or FAP filter"""
 
-        if self._normalization_frequency == 0.0:
+        if self._normalization_frequency in [0.0, None]:
             if self.pass_band is not None:
                 return np.round(10 ** np.mean(np.log10(self.pass_band)), 3)
 
@@ -198,9 +203,7 @@ class ChannelResponse(Base):
         :return: all the non-time_delay filters as a list
 
         """
-        non_delay_filters = [
-            x for x in self.filters_list if x.type != "time delay"
-        ]
+        non_delay_filters = [x for x in self.filters_list if x.type != "time delay"]
         return non_delay_filters
 
     @property
@@ -226,18 +229,26 @@ class ChannelResponse(Base):
             total_delay += delay_filter.delay
         return total_delay
 
-    def get_indices_of_filters_to_remove(self, include_decimation=False, include_delay=False):
+    def get_indices_of_filters_to_remove(
+        self, include_decimation=False, include_delay=False
+    ):
         indices = list(np.arange(len(self.filters_list)))
 
         if not include_delay:
-            indices = [i for i in indices if self.filters_list[i].type != "time delay"]
+            indices = [
+                i for i in indices if self.filters_list[i].type != "time delay"
+            ]
 
         if not include_decimation:
-            indices = [i for i in indices if not self.filters_list[i].decimation_active]
+            indices = [
+                i for i in indices if not self.filters_list[i].decimation_active
+            ]
 
         return indices
 
-    def get_list_of_filters_to_remove(self, include_decimation=False, include_delay=False):
+    def get_list_of_filters_to_remove(
+        self, include_decimation=False, include_delay=False
+    ):
         """
 
         :param include_decimation: bool
@@ -250,8 +261,9 @@ class ChannelResponse(Base):
         #     inverse_filters = [x.inverse() for x in self.filters_list]
         #     self.filters_list = inverse_filters
         """
-        indices = self.get_indices_of_filters_to_remove(include_decimation=include_decimation,
-                                                        include_delay=include_delay)
+        indices = self.get_indices_of_filters_to_remove(
+            include_decimation=include_decimation, include_delay=include_delay
+        )
         return [self.filters_list[i] for i in indices]
 
     def complex_response(
@@ -287,13 +299,17 @@ class ChannelResponse(Base):
 
         # make filters list if not supplied
         if filters_list is None:
-            self.logger.warning("Filters list not provided, building list assuming all are applied")
+            self.logger.warning(
+                "Filters list not provided, building list assuming all are applied"
+            )
             filters_list = self.get_list_of_filters_to_remove(
-                include_decimation=include_decimation,
-            include_delay=include_delay)
+                include_decimation=include_decimation, include_delay=include_delay
+            )
 
         if len(filters_list) == 0:
-            self.logger.warning(f"No filters associated with {self.__class__}, returning 1")
+            self.logger.warning(
+                f"No filters associated with {self.__class__}, returning 1"
+            )
             return np.ones(len(self.frequencies), dtype=complex)
 
         # define the product of all filters as the total response function
@@ -305,10 +321,7 @@ class ChannelResponse(Base):
             result /= np.max(np.abs(result))
         return result
 
-
-    def compute_instrument_sensitivity(
-        self, normalization_frequency=None, sig_figs=6
-    ):
+    def compute_instrument_sensitivity(self, normalization_frequency=None, sig_figs=16):
         """
         Compute the StationXML instrument sensitivity for the given normalization frequency
 
@@ -322,18 +335,41 @@ class ChannelResponse(Base):
             self.normalization_frequency = normalization_frequency
         sensitivity = 1.0
         for mt_filter in self.filters_list:
-            complex_response = mt_filter.complex_response(
-                self.normalization_frequency
-            )
+            complex_response = mt_filter.complex_response(self.normalization_frequency)
             sensitivity *= complex_response.astype(complex)
         try:
             sensitivity = np.abs(sensitivity[0])
         except (IndexError, TypeError):
             sensitivity = np.abs(sensitivity)
 
-        return round(
-            sensitivity, sig_figs - int(np.floor(np.log10(abs(sensitivity))))
-        )
+        return round(sensitivity, sig_figs - int(np.floor(np.log10(abs(sensitivity)))))
+
+    def compute_total_gain(self, sig_figs=16):
+        """
+        Computing the total sensitivity seems to be different than just adding all the gains together.
+        Overall the total sensitivity is useless for MT cause they don't have the ability to use the units.
+        So if a person downloads data from the DMC, they will simply use the filters provided.
+
+        Parameters
+        ----------
+        sig_figs : int, optional
+            _description_, by default 6
+
+        Returns
+        -------
+        _type_
+            _description_
+
+        Raises
+        ------
+        ValueError
+            _description_
+        """
+        total_gain = 1
+        for mt_filter in self.filters_list:
+            total_gain *= mt_filter.gain
+
+        return round(total_gain, sig_figs - int(np.floor(np.log10(abs(total_gain)))))
 
     @property
     def units_in(self):
@@ -355,7 +391,6 @@ class ChannelResponse(Base):
         else:
             return self.filters_list[-1].units_out
 
-
     def _check_consistency_of_units(self):
         """
         confirms that the input and output units of each filter state are consistent
@@ -375,6 +410,7 @@ class ChannelResponse(Base):
 
         return True
 
+    @requires(obspy=inventory)
     def to_obspy(self, sample_rate=1):
         """
         Output :class:`obspy.core.inventory.InstrumentSensitivity` object that
@@ -387,6 +423,13 @@ class ChannelResponse(Base):
 
         """
         total_sensitivity = self.compute_instrument_sensitivity()
+        total_gain = self.compute_total_gain()
+
+        if total_sensitivity != total_gain:
+            self.logger.info(
+                f"total sensitivity {total_sensitivity} != total gain {total_gain}. Using total_gain."
+            )
+            total_sensitivity = total_gain
 
         units_in_obj = get_unit_object(self.units_in)
         units_out_obj = get_unit_object(self.units_out)
@@ -404,9 +447,7 @@ class ChannelResponse(Base):
         for ii, f in enumerate(self.filters_list, 1):
             if f.type in ["coefficient"]:
                 if f.units_out not in ["count"]:
-                    self.logger.debug(
-                        f"converting CoefficientFilter {f.name} to PZ"
-                    )
+                    self.logger.debug(f"converting CoefficientFilter {f.name} to PZ")
                     pz = PoleZeroFilter()
                     pz.gain = f.gain
                     pz.units_in = f.units_in
@@ -484,8 +525,7 @@ class ChannelResponse(Base):
 
         # get response of individual filters
         cr_list = [
-            f.complex_response(self.frequencies, **cr_kwargs)
-            for f in filters_list
+            f.complex_response(self.frequencies, **cr_kwargs) for f in filters_list
         ]
 
         # compute total response

mt_metadata/timeseries/filters/coefficient_filter.py

@@ -1,13 +1,13 @@
-import copy
 import numpy as np
-from obspy.core import inventory
+try:
+    from obspy.core import inventory
+except ImportError:
+    inventory = None
 
 from mt_metadata.base import get_schema
 from mt_metadata.timeseries.filters.filter_base import FilterBase
-from mt_metadata.timeseries.filters.filter_base import get_base_obspy_mapping
 from mt_metadata.timeseries.filters.standards import SCHEMA_FN_PATHS
-from mt_metadata.base.helpers import write_lines
-
+from mt_metadata.base.helpers import write_lines, requires
 
 # =============================================================================
 attr_dict = get_schema("filter_base", SCHEMA_FN_PATHS)
@@ -27,6 +27,7 @@ class CoefficientFilter(FilterBase):
         if self.gain == 0.0:
             self.gain = 1.0
 
+    @requires(obspy=inventory)
     def to_obspy(
         self,
         stage_number=1,

mt_metadata/timeseries/filters/filter_base.py

@@ -41,8 +41,6 @@ of the filter in frequency domain.  It is very similar to an "obspy filter stage
 # =============================================================================
 # Imports
 # =============================================================================
-import copy
-import obspy
 import numpy as np
 
 from mt_metadata.base.helpers import write_lines
@@ -58,6 +56,7 @@ from mt_metadata.utils.mttime import MTime
 attr_dict = get_schema("filter_base", SCHEMA_FN_PATHS)
 # =============================================================================
 
+
 def get_base_obspy_mapping():
     """
     Different filters have different mappings, but the attributes mapped here are common to all of them.
@@ -87,6 +86,7 @@ class FilterBase(Base):
     it may find more application in future.
 
     """
+
     __doc__ = write_lines(attr_dict)
 
     def __init__(self, **kwargs):
@@ -98,6 +98,7 @@ class FilterBase(Base):
         self.comments = None
         self._obspy_mapping = None
         self.gain = 1.0
+        self._name = None
 
         super().__init__(attr_dict=attr_dict, **kwargs)
 
@@ -157,7 +158,6 @@ class FilterBase(Base):
         else:
             self._name = None
 
-
     @property
     def calibration_date(self):
         """
@@ -261,20 +261,17 @@ class FilterBase(Base):
 
         """
 
-        if not isinstance(stage, obspy.core.inventory.response.ResponseStage):
-            msg = f"Expected a Stage and got a {type(stage)}"
-            cls().logger.error(msg)
-            raise TypeError(msg)
-
         if mapping is None:
             mapping = cls().make_obspy_mapping()
         kwargs = {}
-        for obspy_label, mth5_label in mapping.items():
-            try:
-                kwargs[mth5_label] = stage.__dict__[obspy_label]
-            except KeyError:
-                print(f"Key {obspy_label} not found in stage object")
-                raise Exception
+
+        try:
+            for obspy_label, mth5_label in mapping.items():
+                    kwargs[mth5_label] = getattr(stage, obspy_label)
+        except AttributeError:
+            msg = f"Expected a Stage and got a {type(stage)}"
+            cls().logger.error(msg)
+            raise TypeError(msg)
         return cls(**kwargs)
 
     def complex_response(self, frqs):
@@ -403,4 +400,3 @@ class FilterBase(Base):
             if self.decimation_factor != 1.0:
                 return True
         return False
-

mt_metadata/timeseries/filters/fir_filter.py

@@ -1,6 +1,12 @@
 import matplotlib.pyplot as plt
 import numpy as np
-from obspy.core.inventory.response import FIRResponseStage
+
+from mt_metadata.base.helpers import requires
+
+try:
+    from obspy.core.inventory.response import FIRResponseStage
+except ImportError:
+    FIRResponseStage = None
 import scipy.signal as signal
 
 from mt_metadata.base import get_schema
@@ -124,6 +130,7 @@ class FIRFilter(FilterBase):
         plt.axis("tight")
         plt.show()
 
+    @requires(obspy=FIRResponseStage)
     def to_obspy(
         self, stage_number=1, normalization_frequency=1, sample_rate=1,
     ):

mt_metadata/timeseries/filters/frequency_response_table_filter.py

@@ -10,10 +10,15 @@
 import numpy as np
 from scipy.interpolate import interp1d
 
-from obspy.core.inventory.response import (
-    ResponseListResponseStage,
-    ResponseListElement,
-)
+from mt_metadata.base.helpers import requires
+
+try:
+    from obspy.core.inventory.response import (
+        ResponseListResponseStage,
+        ResponseListElement,
+    )
+except ImportError:
+    ResponseListResponseStage = ResponseListElement = None
 
 from mt_metadata.base import get_schema
 from mt_metadata.timeseries.filters.filter_base import FilterBase
@@ -23,9 +28,7 @@ from mt_metadata.timeseries.filters.standards import SCHEMA_FN_PATHS
 
 # =============================================================================
 attr_dict = get_schema("filter_base", SCHEMA_FN_PATHS)
-attr_dict.add_dict(
-    get_schema("frequency_response_table_filter", SCHEMA_FN_PATHS)
-)
+attr_dict.add_dict(get_schema("frequency_response_table_filter", SCHEMA_FN_PATHS))
 
 # =============================================================================
 
@@ -72,7 +75,9 @@ class FrequencyResponseTableFilter(FilterBase):
         if isinstance(value, (list, tuple, np.ndarray)):
             self._empirical_frequencies = np.array(value, dtype=float)
         else:
-            msg = f"input values must be an list, tuple, or np.ndarray, not {type(value)}"
+            msg = (
+                f"input values must be an list, tuple, or np.ndarray, not {type(value)}"
+            )
             self.logger.error(msg)
             raise TypeError(msg)
 
@@ -98,7 +103,9 @@ class FrequencyResponseTableFilter(FilterBase):
             self._empirical_amplitudes = np.array(value, dtype=float)
 
         else:
-            msg = f"input values must be an list, tuple, or np.ndarray, not {type(value)}"
+            msg = (
+                f"input values must be an list, tuple, or np.ndarray, not {type(value)}"
+            )
             self.logger.error(msg)
             raise TypeError(msg)
 
@@ -142,7 +149,9 @@ class FrequencyResponseTableFilter(FilterBase):
                     self._empirical_phases = np.deg2rad(self._empirical_phases)
 
         else:
-            msg = f"input values must be an list, tuple, or np.ndarray, not {type(value)}"
+            msg = (
+                f"input values must be an list, tuple, or np.ndarray, not {type(value)}"
+            )
             self.logger.error(msg)
             raise TypeError(msg)
 
@@ -166,6 +175,7 @@ class FrequencyResponseTableFilter(FilterBase):
         """
         return self._empirical_frequencies.max()
 
+    @requires(obspy=(ResponseListResponseStage and ResponseListElement))
     def to_obspy(
         self,
         stage_number=1,
@@ -186,7 +196,12 @@ class FrequencyResponseTableFilter(FilterBase):
 
         """
         response_elements = []
-        for f, a, p in zip(self.frequencies, self.amplitudes, self.phases):
+        # phase needs to be in degrees.
+        if np.abs(self.phases).max() < 2 * np.pi:
+            phases = np.rad2deg(self.phases)
+        else:
+            phases = self.phases
+        for f, a, p in zip(self.frequencies, self.amplitudes, phases):
             element = ResponseListElement(f, a, p)
             response_elements.append(element)
 

mt_metadata/timeseries/filters/helper_functions.py

@@ -1,5 +1,3 @@
-import obspy
-
 from loguru import logger
 from mt_metadata.timeseries.filters.coefficient_filter import CoefficientFilter
 from mt_metadata.timeseries.filters.frequency_response_table_filter import (

mt_metadata/timeseries/filters/obspy_stages.py

@@ -6,7 +6,10 @@ Idea here is to add logic to interrogate stage filters received from StationXML
 # Imports
 # =============================================================================
 import numpy as np
-import obspy
+try:
+    import obspy
+except ImportError:
+    raise ImportError("obspy_stages requires obspy to be installed.")
 from loguru import logger
 
 from mt_metadata.timeseries.filters import (

mt_metadata/timeseries/filters/pole_zero_filter.py

@@ -7,12 +7,15 @@
 
 """
 import numpy as np
-import obspy
+try:
+    import obspy
+except ImportError:
+    obspy = None
 import scipy.signal as signal
 
 from mt_metadata.base import get_schema
-from mt_metadata.timeseries.filters.filter_base import FilterBase
-from mt_metadata.timeseries.filters.filter_base import get_base_obspy_mapping
+from mt_metadata.base.helpers import requires
+from mt_metadata.timeseries.filters.filter_base import FilterBase, get_base_obspy_mapping
 from mt_metadata.timeseries.filters.standards import SCHEMA_FN_PATHS
 
 # =============================================================================
@@ -21,16 +24,16 @@ attr_dict.add_dict(get_schema("pole_zero_filter", SCHEMA_FN_PATHS))
 # =============================================================================
 
 
-
 class PoleZeroFilter(FilterBase):
     def __init__(self, **kwargs):
 
+        self._poles = np.empty(0, dtype=complex)
+        self._zeros = np.empty(0, dtype=complex)
         super().__init__()
 
         super(FilterBase, self).__init__(attr_dict=attr_dict, **kwargs)
         self.type = "zpk"
 
-
     def make_obspy_mapping(self):
         mapping = get_base_obspy_mapping()
         mapping["_zeros"] = "zeros"
@@ -134,6 +137,7 @@ class PoleZeroFilter(FilterBase):
         """
         return self.gain * self.normalization_factor
 
+    @requires(obspy=obspy)
     def to_obspy(
         self,
         stage_number=1,

mt_metadata/timeseries/filters/time_delay_filter.py

@@ -9,7 +9,13 @@
 """
 
 import numpy as np
-from obspy.core import inventory
+
+from mt_metadata.base.helpers import requires
+
+try:
+    from obspy.core import inventory
+except ImportError:
+    inventory = None
 
 from mt_metadata.base import get_schema
 from mt_metadata.timeseries.filters.filter_base import FilterBase
@@ -35,6 +41,7 @@ class TimeDelayFilter(FilterBase):
         mapping["decimation_delay"] = "delay"
         return mapping
 
+    @requires(obspy=inventory)
     def to_obspy(self, stage_number=1, sample_rate=1, normalization_frequency=0):
         """
         Convert to an obspy stage

mt_metadata/timeseries/location.py

@@ -21,6 +21,8 @@ from . import Declination
 # =============================================================================
 attr_dict = get_schema("location", SCHEMA_FN_PATHS)
 attr_dict.add_dict(get_schema("declination", SCHEMA_FN_PATHS), "declination")
+
+
 # =============================================================================
 class Location(Base):
     __doc__ = write_lines(attr_dict)
@@ -28,6 +30,9 @@ class Location(Base):
     def __init__(self, **kwargs):
 
         self.declination = Declination()
+        self._latitude = 0.0
+        self._longitude = 0.0
+        self._elevation = 0.0
 
         super().__init__(attr_dict=attr_dict, **kwargs)
 
@@ -70,7 +75,9 @@ class Location(Base):
             lat_value = float(latitude)
 
         except TypeError:
-            self.logger.debug("Could not convert {0} setting to 0".format(latitude))
+            self.logger.debug(
+                "Could not convert {0} setting to 0".format(latitude)
+            )
             return 0.0
 
         except ValueError:
@@ -102,7 +109,9 @@ class Location(Base):
             lon_value = float(longitude)
 
         except TypeError:
-            self.logger.debug("Could not convert {0} setting to 0".format(longitude))
+            self.logger.debug(
+                "Could not convert {0} setting to 0".format(longitude)
+            )
             return 0.0
 
         except ValueError:
@@ -130,7 +139,9 @@ class Location(Base):
         try:
             elev_value = float(elevation)
         except (ValueError, TypeError):
-            msg = "Could not convert {0} to a number setting to 0".format(elevation)
+            msg = "Could not convert {0} to a number setting to 0".format(
+                elevation
+            )
             self.logger.debug(msg)
             elev_value = 0.0
 
@@ -188,7 +199,9 @@ class Location(Base):
 
         p_list = position_str.split(":")
         if len(p_list) != 3:
-            msg = "{0} not correct format, should be DD:MM:SS".format(position_str)
+            msg = "{0} not correct format, should be DD:MM:SS".format(
+                position_str
+            )
             self.logger.error(msg)
             raise ValueError(msg)
 
@@ -204,7 +217,9 @@ class Location(Base):
 
         position_value = sign * (abs(deg) + minutes / 60.0 + sec / 3600.0)
 
-        self.logger.debug("Converted {0} to {1}".format(position_str, position_value))
+        self.logger.debug(
+            "Converted {0} to {1}".format(position_str, position_value)
+        )
 
         return position_value
 

mt_metadata/timeseries/person.py

@@ -17,6 +17,8 @@ from .standards import SCHEMA_FN_PATHS
 
 # =============================================================================
 attr_dict = get_schema("person", SCHEMA_FN_PATHS)
+
+
 # =============================================================================
 class Person(Base):
     __doc__ = write_lines(attr_dict)
@@ -25,10 +27,15 @@ class Person(Base):
 
         super().__init__(attr_dict=attr_dict, **kwargs)
 
-    @property
-    def author(self):
-        return self.name
-
-    @author.setter
-    def author(self, value):
-        self.name = value
+    # @property
+    # def author(self):
+    #     if self.name is None:
+    #         return
+    #     return self.name
+
+    # @author.setter
+    # def author(self, value):
+    #     if value is None:
+    #         self.name = None
+    #     else:
+    #         self.name = value

mt_metadata/timeseries/standards/person.json

@@ -1,7 +1,7 @@
 {
     "name": {
         "type": "string",
-        "required": true,
+        "required": false,
         "style": "free form",
         "units": null,
         "description": "Persons name, should be full first and last name.",

mt_metadata/timeseries/standards/run.json

@@ -66,10 +66,10 @@
         "required": true,
         "style": "alpha numeric",
         "units": null,
-        "description": "Run ID should be station name followed by a number or character.  Characters should only be used if the run number is small, if the run number is high consider using digits with zeros.  For example if you have 100 runs the run ID could be 001 or {station}001.",
+        "description": "Suggested Run ID should be sample rate followed by a number or character.  Characters should only be used if the run number is small, if the run number is high consider using digits with zeros.  For example if you have 100 runs the run ID could be 001 or sr{sample_rate}_001.",
         "options": [],
         "alias": [],
-        "example": "001",
+        "example": "sr100_001",
 		"default": null
     },
     "sample_rate": {