mt-metadata 0.3.4__py2.py3-none-any.whl → 0.3.5__py2.py3-none-any.whl

mt_metadata/__init__.py

@@ -39,7 +39,7 @@ you should only have to changes these dictionaries.
 
 __author__ = """Jared Peacock"""
 __email__ = "jpeacock@usgs.gov"
-__version__ = "0.3.4"
+__version__ = "0.3.5"
 
 # =============================================================================
 # Imports

mt_metadata/base/metadata.py

@@ -300,7 +300,7 @@ class Base:
             self.logger.exception(error)
             raise MTSchemaError(error)
 
-    def _validate_option(self, name, option_list):
+    def _validate_option(self, name, value, option_list):
         """
         validate the given attribute name agains possible options and check
         for aliases
@@ -315,21 +315,21 @@ class Base:
         :rtype: TYPE
 
         """
-        if name is None:
+        if value is None:
             return True, False, None
         options = [ss.lower() for ss in option_list]
         other_possible = False
         if "other" in options:
             other_possible = True
-        if name.lower() in options:
+        if value.lower() in options:
             return True, other_possible, None
-        elif name.lower() not in options and other_possible:
+        elif value.lower() not in options and other_possible:
             msg = (
-                "{0} not found in options list {1}, but other options"
-                + " are allowed.  Allowing {2} to be set to {0}."
+                f"Value '{value}' not found for metadata field '{name}' in options list {option_list}, but other options"
+                + f" are allowed.  Allowing {option_list} to be set to {value}."
             )
             return True, other_possible, msg
-        return False, other_possible, "{0} not found in options list {1}"
+        return False, other_possible, f"Value '{value}' for metadata field '{name}' not found in options list {option_list}"
 
     def __setattr__(self, name, value):
         """
@@ -399,7 +399,7 @@ class Base:
                 # check options
                 if v_dict["style"] == "controlled vocabulary":
                     options = v_dict["options"]
-                    accept, other, msg = self._validate_option(value, options)
+                    accept, other, msg = self._validate_option(name, value, options)
                     if not accept:
                         self.logger.error(msg.format(value, options))
                         raise MTSchemaError(msg.format(value, options))

mt_metadata/timeseries/stationxml/xml_inventory_mt_experiment.py

@@ -170,7 +170,10 @@ class XMLInventoryMTExperiment:
             xml_network = self.network_translator.mt_to_xml(mt_survey)
             for mt_station in mt_survey.stations:
                 xml_station = self.station_translator.mt_to_xml(mt_station)
-                xml_station.site.country = mt_survey.country
+                if mt_survey.country is not None:
+                    xml_station.site.country = ",".join(
+                        [str(country) for country in mt_survey.country]
+                    )
                 for mt_run in mt_station.runs:
                     xml_station = self.add_run(
                         xml_station, mt_run, mt_survey.filters

mt_metadata/timeseries/tools/from_many_mt_files.py

@@ -12,7 +12,14 @@ from pathlib import Path
 import pandas as pd
 from xml.etree import cElementTree as et
 
-from mt_metadata.timeseries import Experiment, Survey, Station, Run, Electric, Magnetic
+from mt_metadata.timeseries import (
+    Experiment,
+    Survey,
+    Station,
+    Run,
+    Electric,
+    Magnetic,
+)
 
 from mt_metadata.timeseries.filters import (
     PoleZeroFilter,
@@ -22,6 +29,7 @@ from mt_metadata.timeseries.filters import (
 )
 from mt_metadata.timeseries.stationxml import XMLInventoryMTExperiment
 
+
 # =============================================================================
 # Useful Class
 # =============================================================================
@@ -182,7 +190,7 @@ class MT2StationXML(XMLInventoryMTExperiment):
         channels_list = []
         for ch in order:
             for fn in rdf:
-                if ch in fn.name.lower():
+                if ch in fn.name[len(station) :].lower():
                     channels_list.append(fn)
                     break
 
@@ -196,7 +204,11 @@ class MT2StationXML(XMLInventoryMTExperiment):
         :rtype: TYPE
 
         """
-        fn_dict = {"survey": self.survey, "filters": self.filters, "stations": []}
+        fn_dict = {
+            "survey": self.survey,
+            "filters": self.filters,
+            "stations": [],
+        }
         if stations in [None, []]:
             station_iterator = self.stations
         else:

mt_metadata/transfer_functions/processing/aurora/band.py

@@ -24,6 +24,7 @@ class Band(Base):
     def __init__(self, **kwargs):
 
         super().__init__(attr_dict=attr_dict, **kwargs)
+        self._name = None
 
     @property
     def lower_bound(self):
@@ -41,6 +42,21 @@ class Band(Base):
     def upper_closed(self):
         return self.to_interval().closed_right
 
+    @property
+    def name(self):
+        """
+        :return: The name of the frequency band (currently defaults to fstring with 6 decimal places.
+        :rtype: str
+        """
+        if self._name is None:
+            self._name = f"{self.center_frequency:.6f}"
+        return self._name
+
+
+    @name.setter
+    def name(self, value):
+        self._name = value
+
     def _indices_from_frequencies(self, frequencies):
         """
 

mt_metadata/transfer_functions/processing/fourier_coefficients/standards/decimation.json

@@ -4,7 +4,7 @@
         "required": true,
         "style": "number",
         "units": null,
-        "description": "Decimation level, must be a positive integer starting at 0.",
+        "description": "Decimation level, must be a non-negative integer starting at 0",
         "options": [],
         "alias": [],
         "example": "1",

{mt_metadata-0.3.4.dist-info → mt_metadata-0.3.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mt-metadata
-Version: 0.3.4
+Version: 0.3.5
 Summary: Metadata for magnetotelluric data
 Home-page: https://github.com/kujaku11/mt_metadata
 Author: Jared Peacock
@@ -28,7 +28,7 @@ Requires-Dist: matplotlib
 Requires-Dist: xarray
 Requires-Dist: loguru
 
-# mt_metadata version 0.3.4
+# mt_metadata version 0.3.5
  Standard MT metadata
 
 [![PyPi version](https://img.shields.io/pypi/v/mt_metadata.svg)](https://pypi.python.org/pypi/mt-metadata)
@@ -58,7 +58,7 @@ MT Metadata is a project led by [IRIS-PASSCAL MT Software working group](https:/
 
 Most people will be using the transfer functions, but a lot of that metadata comes from the time series metadata.  This module supports both and has tried to make them more or less seamless to reduce complication.
 
-* **Version**: 0.3.4
+* **Version**: 0.3.5
 * **Free software**: MIT license
 * **Documentation**: https://mt-metadata.readthedocs.io.
 * **Examples**: Click the `Binder` badge above and Jupyter Notebook examples are in **mt_metadata/examples/notebooks** and **docs/source/notebooks**

{mt_metadata-0.3.4.dist-info → mt_metadata-0.3.5.dist-info}/RECORD

@@ -1,7 +1,7 @@
-mt_metadata/__init__.py,sha256=yDD8tnPwN4hjj0ZOfrtCtW41zqGbBWK2pjAbrleQ_yQ,5588
+mt_metadata/__init__.py,sha256=CmllQ7LH3dBndOB3nUPeBxK2sQMDqPyhjhdr2byrOJY,5588
 mt_metadata/base/__init__.py,sha256=bylCGBoJkeytxeQgMnuqivqFAvbyNE5htvP-3yu1GEY,184
 mt_metadata/base/helpers.py,sha256=oS4s7OysTQZ5J8VVPUJYYuVkqviSIlOwnNFKZe5FWIc,19721
-mt_metadata/base/metadata.py,sha256=xl_GwpCfB7qFXR05VjFsCLz5dE0qAoYKl9GuSmvtGVw,27012
+mt_metadata/base/metadata.py,sha256=obOFdU6FPf2o-SbdxOxZ60LvzbI6Cp-bbRXw8KdkBao,27145
 mt_metadata/base/schema.py,sha256=MvZBvy2elYia5VLRXqOV9x0GIklEWLM4qpTdqo820P4,12842
 mt_metadata/data/__init__.py,sha256=PECwullCdCwKGpd1fkQc1jL8CboaSQfy_Cdm-obl-Y8,217
 mt_metadata/data/mt_xml/__init__.py,sha256=fsW8De_Dhrjp55R12F2RH5M6QHoPO3Qf51yR3AFWztg,26
@@ -75,7 +75,6 @@ mt_metadata/timeseries/time_period.py,sha256=eUFucwMY8Gsoi375pwuPlrg-HCBENU6UJ-s
 mt_metadata/timeseries/timing_system.py,sha256=3Uvu_Ihk1b1SyPFMKHWCDe1_BUfiVYphpatRP3wwS-s,839
 mt_metadata/timeseries/filters/__init__.py,sha256=9FaNM3OVQ1dMiAn5JyfSK8QtICqGXH6TaKhPYjbpgj8,474
 mt_metadata/timeseries/filters/channel_response.py,sha256=yxPaukC2yyEJFayniSyH2IPNGgE4oDIFMmTp4o3jJ1I,17297
-mt_metadata/timeseries/filters/channel_response_filter.py,sha256=8qcQF4UUd_W1FVKQcq_4rII1ZR-sImYhwo6ALhtSoWs,15626
 mt_metadata/timeseries/filters/coefficient_filter.py,sha256=HryPmsFGr-SEkox85DBYc3q8A3M4C_Hmjc-CNvm6e-w,3322
 mt_metadata/timeseries/filters/filter_base.py,sha256=IiPhOkVvJUbdboFxWWeKyj1iKdW1HE061nvBdw6G8TM,12885
 mt_metadata/timeseries/filters/filtered.py,sha256=0o3aFYLhtSeBgpgi5ndSsKGbE5tBJhY_wEq5oQblhOg,6979
@@ -126,11 +125,11 @@ mt_metadata/timeseries/stationxml/fdsn_tools.py,sha256=6H1hZCxf5-skNSjPazMS_wKu4
 mt_metadata/timeseries/stationxml/utils.py,sha256=16617e6snyrsNjletGbw-gLYQ2vt-7VfYPokz6dakts,7257
 mt_metadata/timeseries/stationxml/xml_channel_mt_channel.py,sha256=Pkyg3plhwOp02Yl_ymbsWU0eydpE-lA8OqAo-Yoo1HM,20289
 mt_metadata/timeseries/stationxml/xml_equipment_mt_run.py,sha256=yRPk6lhnzkpgARe6lQkU_-vZrTDDmIIeRCTI9Wig9XY,5151
-mt_metadata/timeseries/stationxml/xml_inventory_mt_experiment.py,sha256=XUjXQBJg_94ZP-FDyOHPVJWeNPV2oR8oh20hsaJDZeE,13893
+mt_metadata/timeseries/stationxml/xml_inventory_mt_experiment.py,sha256=cmDJybDh6-JgzEHQM0CuLeDTIKoNnIyn9PnYrzV1RZs,14036
 mt_metadata/timeseries/stationxml/xml_network_mt_survey.py,sha256=RciEmnFGb8kMf1mA1lLn9d0R7WiOW2BeoV1bDB-eJuU,7124
 mt_metadata/timeseries/stationxml/xml_station_mt_station.py,sha256=pelvkiQios4gz8gHebWY1MPSsfBhfTz6uTgC92Yz9-4,11112
 mt_metadata/timeseries/tools/__init__.py,sha256=loPgjYnajbOX2rQTlLBh79cG2eaUNpI3KaCjp7SB4ik,78
-mt_metadata/timeseries/tools/from_many_mt_files.py,sha256=qx_sRPlPe5-VkaqNpC_lHtmgN4FI6Hmd2F1WANPZBC8,14300
+mt_metadata/timeseries/tools/from_many_mt_files.py,sha256=rtx5NAPBUmOgrMXUT-YJxznqfI1qdRkS4B2SWjrU_1c,14405
 mt_metadata/transfer_functions/__init__.py,sha256=wpGghfoqFj4nuFOoHeR8PFGQGMzkWvTb3T_KfmMWswQ,42
 mt_metadata/transfer_functions/core.py,sha256=70hxEFszjZzed-OKFcmF-B_Tm_Zy7212dPJPCF0_lMA,79933
 mt_metadata/transfer_functions/io/__init__.py,sha256=8DKEQZrpF0RK_MTjR0_w0UQfgVf9VwuJrzy7eann1N8,215
@@ -277,7 +276,7 @@ mt_metadata/transfer_functions/io/zonge/metadata/standards/tx.json,sha256=W0ITo4
 mt_metadata/transfer_functions/io/zonge/metadata/standards/unit.json,sha256=A2KIoTXBANiqp8Mjxg3VDZbjNPgASnS7QVdK7KOJ0y8,953
 mt_metadata/transfer_functions/processing/__init__.py,sha256=frcCV1k9oG9oKj3dpUqdJg1PxRT2RSN_XKdLCPjaYaY,2
 mt_metadata/transfer_functions/processing/aurora/__init__.py,sha256=zczI5zoF7ceLEdu0gkmsLbBYJ2rxuyWsYIjZtxwQP8g,668
-mt_metadata/transfer_functions/processing/aurora/band.py,sha256=YaVSXxjjlw0zJgZ-KlMadAFU4mKqYM_6urXU7OHjaPs,8100
+mt_metadata/transfer_functions/processing/aurora/band.py,sha256=pBk8fYXhJ0S_lyWH3JQIbUr3ZeDKkU93pybSUy5jtbE,8509
 mt_metadata/transfer_functions/processing/aurora/channel.py,sha256=TZHfy-XgrijdNVd4Sjbq3tjORFsJNZIzwa4_J7tDOHM,773
 mt_metadata/transfer_functions/processing/aurora/channel_nomenclature.py,sha256=GD6teHAtBUKTkGGDWX2clZwk1Fac8ndCOZ3r8TJDGrY,4264
 mt_metadata/transfer_functions/processing/aurora/decimation.py,sha256=AF7vdU-Q7W4yfnJoPDbhDqgxJTtHiLCLEUDLBEzfmFM,785
@@ -309,7 +308,7 @@ mt_metadata/transfer_functions/processing/fourier_coefficients/decimation.py,sha
 mt_metadata/transfer_functions/processing/fourier_coefficients/fc.py,sha256=bN3S_0uoMqXDcJcw_7oYN3YQqsWITD2UX0aRcgdY7fw,10450
 mt_metadata/transfer_functions/processing/fourier_coefficients/fc_channel.py,sha256=HFFo2XoqaKJOae3mtRSMZ80_AZ6wDx0KKq3oBfIbJKg,926
 mt_metadata/transfer_functions/processing/fourier_coefficients/standards/__init__.py,sha256=Y3rdyXKOgxbSh9FQxQCCplsbqxwWmFIGm6yZG1cj0Uw,135
-mt_metadata/transfer_functions/processing/fourier_coefficients/standards/decimation.json,sha256=Ws10Rs8AL77Sm6KWlRDV5htYZtfm_VBCDj9uqV1uKdQ,3769
+mt_metadata/transfer_functions/processing/fourier_coefficients/standards/decimation.json,sha256=aatnDixbOC_lPsBE26iXuGTxCnT6uBZAU_VX6iLosbg,3772
 mt_metadata/transfer_functions/processing/fourier_coefficients/standards/fc.json,sha256=ZiIvXRkYIU3tOcUKeIhBwZtDIdm4rlnG4zUMdiKzOT0,1523
 mt_metadata/transfer_functions/processing/fourier_coefficients/standards/fc_channel.json,sha256=pdR6r2BQTmrw8udtjaVz0Z9zmeX_Jd1uezuBQfKd7kY,1873
 mt_metadata/transfer_functions/tf/__init__.py,sha256=rJN-VGiGjCWBzFpruDOQitM8v-dfON9tKgZzX8zAhsI,3890
@@ -331,9 +330,9 @@ mt_metadata/utils/mttime.py,sha256=6XRIlY6eaSwLqNnRTeaDraQz4sk0PN27Z7z6BMeZkbk,1
 mt_metadata/utils/summarize.py,sha256=KisJt2PWz1-_FOBH8NQtidgxjdWPAbIDwPzEB197uhs,4109
 mt_metadata/utils/units.py,sha256=OdALLmytoPvjJ8rYf7QsGq1b8nrNt85A8wUhjqRyTOo,6405
 mt_metadata/utils/validators.py,sha256=vj55VvH11A0H9SeUcVy9lJCDKNzwCiMTSra-_Ws1Ojk,16264
-mt_metadata-0.3.4.dist-info/AUTHORS.rst,sha256=3RKy4std2XZQLNF6xYIiA8S5A0bBPqNO7ypJsuEhiN8,706
-mt_metadata-0.3.4.dist-info/LICENSE,sha256=P33RkFPriIBxsgZtVzSn9KxYa2K7Am42OwMV0h_m5e0,1080
-mt_metadata-0.3.4.dist-info/METADATA,sha256=CTPVq3wSMWfy548axtCT2ifis4Q1eXkEg3pJ2Hg8KMI,17286
-mt_metadata-0.3.4.dist-info/WHEEL,sha256=iYlv5fX357PQyRT2o6tw1bN-YcKFFHKqB_LwHO5wP-g,110
-mt_metadata-0.3.4.dist-info/top_level.txt,sha256=fxe_q_GEd9h6iR3050ZnrhSfxUSO5pR8u65souS4RWM,12
-mt_metadata-0.3.4.dist-info/RECORD,,
+mt_metadata-0.3.5.dist-info/AUTHORS.rst,sha256=3RKy4std2XZQLNF6xYIiA8S5A0bBPqNO7ypJsuEhiN8,706
+mt_metadata-0.3.5.dist-info/LICENSE,sha256=P33RkFPriIBxsgZtVzSn9KxYa2K7Am42OwMV0h_m5e0,1080
+mt_metadata-0.3.5.dist-info/METADATA,sha256=Vz1gxXzTNbwIH3WLimJ5zd2jyQt5QBO5gZHDmWYOWAk,17286
+mt_metadata-0.3.5.dist-info/WHEEL,sha256=DZajD4pwLWue70CAfc7YaxT1wLUciNBvN_TTcvXpltE,110
+mt_metadata-0.3.5.dist-info/top_level.txt,sha256=fxe_q_GEd9h6iR3050ZnrhSfxUSO5pR8u65souS4RWM,12
+mt_metadata-0.3.5.dist-info/RECORD,,

{mt_metadata-0.3.4.dist-info → mt_metadata-0.3.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.41.2)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py2-none-any
 Tag: py3-none-any

mt_metadata/timeseries/filters/channel_response_filter.py

@@ -1,476 +0,0 @@
-"""
-==========================
-Channel Response Filter
-==========================
-
-Combines all filters for a given channel into a total response that can be used in 
-the frequency domain.
-
-.. note:: Time Delay filters should be applied in the time domain 
-    otherwise bad things can happen.   
-"""
-# =============================================================================
-# Imports
-# =============================================================================
-from copy import deepcopy
-import numpy as np
-
-from mt_metadata.base import Base, get_schema
-from mt_metadata.timeseries.filters.standards import SCHEMA_FN_PATHS
-from mt_metadata.timeseries.filters import (
-    PoleZeroFilter,
-    CoefficientFilter,
-    TimeDelayFilter,
-    FrequencyResponseTableFilter,
-    FIRFilter,
-)
-from mt_metadata.utils.units import get_unit_object
-from mt_metadata.timeseries.filters.plotting_helpers import plot_response
-from obspy.core import inventory
-
-# =============================================================================
-attr_dict = get_schema("channel_response", SCHEMA_FN_PATHS)
-# =============================================================================
-
-
-class ChannelResponseFilter(Base):
-    """
-    This class holds a list of all the filters associated with a channel.
-    It has methods for combining the responses of all the filters into a total
-    response that we will apply to a data segment.
-    """
-
-    def __init__(self, **kwargs):
-        self.filters_list = []
-        self.frequencies = np.logspace(-4, 4, 100)
-        self.normalization_frequency = None
-
-        super().__init__(attr_dict=attr_dict)
-        for k, v in kwargs.items():
-            setattr(self, k, v)
-
-    def __str__(self):
-        lines = ["Filters Included:\n", "=" * 25, "\n"]
-        for f in self.filters_list:
-            lines.append(f.__str__())
-            lines.append(f"\n{'-'*20}\n")
-
-        return "".join(lines)
-
-    def __repr__(self):
-        return self.__str__()
-
-    @property
-    def filters_list(self):
-        """filters list"""
-        return self._filters_list
-
-    @filters_list.setter
-    def filters_list(self, filters_list):
-        """set the filters list and validate the list"""
-        self._filters_list = self._validate_filters_list(filters_list)
-        self._check_consistency_of_units()
-
-    @property
-    def frequencies(self):
-        """frequencies to estimate filters"""
-        return self._frequencies
-
-    @frequencies.setter
-    def frequencies(self, value):
-        """
-        Set the frequencies, make sure the input is validated
-
-        Linear frequencies
-        :param value: Linear Frequencies
-        :type value: iterable
-
-        """
-        if value is None:
-            self._frequencies = None
-
-        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)}"
-            self.logger.error(msg)
-            raise TypeError(msg)
-
-    @property
-    def names(self):
-        """names of the filters"""
-        names = []
-        if self.filters_list:
-            names = [f.name for f in self.filters_list]
-        return names
-
-    def _validate_filters_list(self, filters_list):
-        """
-        make sure the filters list is valid
-
-        :param filters_list: DESCRIPTION
-        :type filters_list: TYPE
-        :return: DESCRIPTION
-        :rtype: TYPE
-
-        """
-        ACCEPTABLE_FILTERS = [
-            PoleZeroFilter,
-            CoefficientFilter,
-            TimeDelayFilter,
-            FrequencyResponseTableFilter,
-            FIRFilter,
-        ]
-
-        def is_acceptable_filter(item):
-            if isinstance(item, tuple(ACCEPTABLE_FILTERS)):
-                return True
-            else:
-                return False
-
-        if filters_list in [[], None]:
-            return []
-
-        if not isinstance(filters_list, list):
-            msg = f"Input filters list must be a list not {type(filters_list)}"
-            self.logger.error(msg)
-            raise TypeError(msg)
-
-        fails = []
-        return_list = []
-        for item in filters_list:
-            if is_acceptable_filter(item):
-                return_list.append(item)
-            else:
-                fails.append(
-                    f"Item is not an acceptable filter type, {type(item)}"
-                )
-
-        if fails:
-            raise TypeError(", ".join(fails))
-
-        return return_list
-
-    @property
-    def pass_band(self):
-        """estimate pass band for all filters in frequency"""
-        if self.frequencies is None:
-            raise ValueError(
-                "frequencies are None, must be input to calculate pass band"
-            )
-        pb = []
-        for f in self.filters_list:
-            if hasattr(f, "pass_band"):
-                f_pb = f.pass_band(self.frequencies)
-                if f_pb is None:
-                    continue
-                pb.append((f_pb.min(), f_pb.max()))
-
-        if pb != []:
-            pb = np.array(pb)
-            return np.array([pb[:, 0].max(), pb[:, 1].min()])
-        return None
-
-    @property
-    def normalization_frequency(self):
-        """get normalization frequency from ZPK or FAP filter"""
-
-        if self._normalization_frequency == 0.0:
-            if self.pass_band is not None:
-                return np.round(10 ** np.mean(np.log10(self.pass_band)), 3)
-
-        return self._normalization_frequency
-
-    @normalization_frequency.setter
-    def normalization_frequency(self, value):
-        """Set normalization frequency if input"""
-
-        self._normalization_frequency = value
-
-    @property
-    def non_delay_filters(self):
-        """
-
-        :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"
-        ]
-        return non_delay_filters
-
-    @property
-    def delay_filters(self):
-        """
-
-        :return: all the time delay filters as a list
-
-        """
-        delay_filters = [x for x in self.filters_list if x.type == "time delay"]
-        return delay_filters
-
-    @property
-    def total_delay(self):
-        """
-
-        :return: the total delay of all filters
-
-        """
-        delay_filters = self.delay_filters
-        total_delay = 0.0
-        for delay_filter in delay_filters:
-            total_delay += delay_filter.delay
-        return total_delay
-
-    def complex_response(
-        self,
-        frequencies=None,
-        include_delay=False,
-        normalize=False,
-        include_decimation=True,
-        **kwargs,
-    ):
-        """
-
-        :param frequencies: frequencies to compute complex response,
-         defaults to None
-        :type frequencies: np.ndarray, optional
-        :param include_delay: include delay in complex response,
-         defaults to False
-        :type include_delay: bool, optional
-        :param normalize: normalize the response to 1, defaults to False
-        :type normalize: bool, optional
-        :param include_decimation: Include decimation in response,
-         defaults to True
-        :type include_decimation: bool, optional
-        :return: complex response along give frequency array
-        :rtype: np.ndarray
-
-        """
-
-        if frequencies is not None:
-            self.frequencies = frequencies
-
-        if include_delay:
-            filters_list = deepcopy(self.filters_list)
-        else:
-            filters_list = deepcopy(self.non_delay_filters)
-
-        if not include_decimation:
-            filters_list = deepcopy(
-                [x for x in filters_list if not x.decimation_active]
-            )
-
-        if len(filters_list) == 0:
-            # warn that there are no filters associated with channel?
-            return np.ones(len(self.frequencies), dtype=complex)
-
-        result = filters_list[0].complex_response(self.frequencies)
-
-        for ff in filters_list[1:]:
-            result *= ff.complex_response(self.frequencies)
-
-        if normalize:
-            result /= np.max(np.abs(result))
-        return result
-
-    def compute_instrument_sensitivity(
-        self, normalization_frequency=None, sig_figs=6
-    ):
-        """
-        Compute the StationXML instrument sensitivity for the given normalization frequency
-
-        :param normalization_frequency: DESCRIPTION
-        :type normalization_frequency: TYPE
-        :return: DESCRIPTION
-        :rtype: TYPE
-
-        """
-        if normalization_frequency is not None:
-            self.normalization_frequency = normalization_frequency
-        sensitivity = 1.0
-        for mt_filter in self.filters_list:
-            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))))
-        )
-
-    @property
-    def units_in(self):
-        """
-        :return: the units of the channel
-        """
-        if self.filters_list is [] or len(self.filters_list) == 0:
-            return None
-
-        return self.filters_list[0].units_in
-
-    @property
-    def units_out(self):
-        """
-        :return: the units of the channel
-        """
-        if self.filters_list is [] or len(self.filters_list) == 0:
-            return None
-
-        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
-        """
-        if len(self._filters_list) > 1:
-            previous_units = self._filters_list[0].units_out
-            for mt_filter in self._filters_list[1:]:
-                if mt_filter.units_in != previous_units:
-                    msg = (
-                        "Unit consistency is incorrect. "
-                        f"The input units for {mt_filter.name} should be "
-                        f"{previous_units} not {mt_filter.units_in}"
-                    )
-                    self.logger.error(msg)
-                    raise ValueError(msg)
-                previous_units = mt_filter.units_out
-
-        return True
-
-    def to_obspy(self, sample_rate=1):
-        """
-        Output :class:`obspy.core.inventory.InstrumentSensitivity` object that
-        can be used in a stationxml file.
-
-        :param normalization_frequency: DESCRIPTION
-        :type normalization_frequency: TYPE
-        :return: DESCRIPTION
-        :rtype: TYPE
-
-        """
-        total_sensitivity = self.compute_instrument_sensitivity()
-
-        units_in_obj = get_unit_object(self.units_in)
-        units_out_obj = get_unit_object(self.units_out)
-
-        total_response = inventory.Response()
-        total_response.instrument_sensitivity = inventory.InstrumentSensitivity(
-            total_sensitivity,
-            self.normalization_frequency,
-            units_in_obj.abbreviation,
-            units_out_obj.abbreviation,
-            input_units_description=units_in_obj.name,
-            output_units_description=units_out_obj.name,
-        )
-
-        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"
-                    )
-                    pz = PoleZeroFilter()
-                    pz.gain = f.gain
-                    pz.units_in = f.units_in
-                    pz.units_out = f.units_out
-                    pz.comments = f.comments
-                    pz.name = f.name
-                else:
-                    pz = f
-
-                total_response.response_stages.append(
-                    pz.to_obspy(
-                        stage_number=ii,
-                        normalization_frequency=self.normalization_frequency,
-                        sample_rate=sample_rate,
-                    )
-                )
-            else:
-                total_response.response_stages.append(
-                    f.to_obspy(
-                        stage_number=ii,
-                        normalization_frequency=self.normalization_frequency,
-                        sample_rate=sample_rate,
-                    )
-                )
-
-        return total_response
-
-    def plot_response(
-        self,
-        frequencies=None,
-        x_units="period",
-        unwrap=True,
-        pb_tol=1e-1,
-        interpolation_method="slinear",
-        include_delay=False,
-        include_decimation=True,
-    ):
-        """
-        Plot the response
-
-        :param frequencies: frequencies to compute response, defaults to None
-        :type frequencies: np.ndarray, optional
-        :param x_units: [ period | frequency ], defaults to "period"
-        :type x_units: string, optional
-        :param unwrap: Unwrap phase, defaults to True
-        :type unwrap: bool, optional
-        :param pb_tol: pass band tolerance, defaults to 1e-1
-        :type pb_tol: float, optional
-        :param interpolation_method: Interpolation method see scipy.signal.interpolate
-         [ slinear | nearest | cubic | quadratic | ], defaults to "slinear"
-        :type interpolation_method: string, optional
-        :param include_delay: include delays in response, defaults to False
-        :type include_delay: bool, optional
-        :param include_decimation: Include decimation in response,
-         defaults to True
-        :type include_decimation: bool, optional
-
-        """
-
-        if frequencies is not None:
-            self.frequencies = frequencies
-
-        # get only the filters desired
-        if include_delay:
-            filters_list = deepcopy(self.filters_list)
-        else:
-            filters_list = deepcopy(self.non_delay_filters)
-
-        if not include_decimation:
-            filters_list = deepcopy(
-                [x for x in filters_list if not x.decimation_active]
-            )
-
-        cr_kwargs = {"interpolation_method": interpolation_method}
-
-        # get response of individual filters
-        cr_list = [
-            f.complex_response(self.frequencies, **cr_kwargs)
-            for f in filters_list
-        ]
-
-        # compute total response
-        cr_kwargs["include_delay"] = include_delay
-        cr_kwargs["include_decimation"] = include_decimation
-        complex_response = self.complex_response(self.frequencies, **cr_kwargs)
-
-        cr_list.append(complex_response)
-        labels = [f.name for f in filters_list] + ["Total Response"]
-
-        # plot with proper attributes.
-        kwargs = {
-            "title": f"Channel Response: [{', '.join([f.name for f in filters_list])}]",
-            "unwrap": unwrap,
-            "x_units": x_units,
-            "pass_band": self.pass_band,
-            "label": labels,
-            "normalization_frequency": self.normalization_frequency,
-        }
-
-        plot_response(self.frequencies, cr_list, **kwargs)