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

mt_metadata/timeseries/filters/filtered.py

@@ -2,7 +2,7 @@
 """
 Created on Wed Dec 23 21:30:36 2020
 
-:copyright: 
+:copyright:
     Jared Peacock (jpeacock@usgs.gov)
 
 :license: MIT
@@ -62,13 +62,10 @@ class Filtered(Base):
 
         check = self._check_consistency()
         if not check:
-            self.logger.debug(
-                "Filter names and applied lists are not the "
-                + "same size. Be sure to check the inputs."
-                + " names = {0}, applied = {1}".format(
-                    self._name, self._applied
-                )
-            )
+            msg = (f"Filter names and applied lists are not the same size. "
+                   f"Be sure to check the inputs. "
+                   f"names = {self._name}, applied = {self._applied}")
+            self.logger.warning(msg)
 
     @property
     def applied(self):
@@ -77,17 +74,21 @@ class Filtered(Base):
     @applied.setter
     def applied(self, applied):
         if not hasattr(applied, "__iter__"):
-            if applied in [None, "none", "None", "NONE", "null", 0, "0"]:
+            if applied in [None, "none", "None", "NONE", "null"]:
+                self._applied = [True]
+                return
+            elif applied in [0, "0"]:
                 self._applied = [False]
                 return
+
+        #sets an empty list to one default value
         if isinstance(applied, list) and len(applied) == 0:
-            self.applied = [False]
+            self.applied = [True]
             return
 
         if isinstance(applied, str):
             if applied.find("[") >= 0:
                 applied = applied.replace("[", "").replace("]", "")
-
             if applied.count(",") > 0:
                 applied_list = [
                     ss.strip().lower() for ss in applied.split(",")
@@ -96,13 +97,21 @@ class Filtered(Base):
                 applied_list = [ss.lower() for ss in applied.split()]
         elif isinstance(applied, list):
             applied_list = applied
+            # set integer strings to integers ["0","1"]--> [0, 1]
+            for i, elt in enumerate(applied_list):
+                if elt in ["0", "1",]:
+                    applied_list[i] = int(applied_list[i])
+            # set integers to bools [0,1]--> [False, True]
+            for i, elt in enumerate(applied_list):
+                if elt in [0, 1,]:
+                    applied_list[i] = bool(applied_list[i])
         elif isinstance(applied, bool):
             applied_list = [applied]
         # the returned type from a hdf5 dataset is a numpy array.
         elif isinstance(applied, np.ndarray):
             applied_list = list(applied)
             if applied_list == []:
-                applied_list = [False]
+                applied_list = [True]
         else:
             msg = "applied must be a string or list of strings not {0}"
             self.logger.error(msg.format(applied))
@@ -111,8 +120,8 @@ class Filtered(Base):
         bool_list = []
         for app_bool in applied_list:
             if app_bool is None:
-                bool_list.append(False)
-            if isinstance(app_bool, str):
+                bool_list.append(True)
+            elif isinstance(app_bool, str):
                 if app_bool.lower() in ["false", "0"]:
                     bool_list.append(False)
                 elif app_bool.lower() in ["true", "1"]:
@@ -131,13 +140,11 @@ class Filtered(Base):
         # check for consistency
         check = self._check_consistency()
         if not check:
-            self.logger.debug(
-                "Filter names and applied lists are not the "
-                + "same size. Be sure to check the inputs."
-                + ". name = {0}, applied = {1}".format(
-                    self._name, self._applied
-                )
-            )
+            msg = (f"Filter names and applied lists are not the same size. "
+                   f"Be sure to check the inputs. "
+                   f"names = {self._name}, applied = {self._applied}")
+            self.logger.warning(msg)
+
 
     def _check_consistency(self):
         # check for consistency
@@ -165,7 +172,10 @@ class Filtered(Base):
                             )
                         )
                         return False
-        elif self._name == [] and self._applied == [False]:
+                    else:
+                        return True
+        elif self._name == [] and len(self._applied) > 0:
+            self.logger.debug("Name probably not yet initialized -- skipping consitency check")
             return True
         else:
             return False

mt_metadata/timeseries/filters/fir_filter.py

@@ -1,4 +1,3 @@
-import copy
 import matplotlib.pyplot as plt
 import numpy as np
 from obspy.core.inventory.response import FIRResponseStage
@@ -6,7 +5,7 @@ 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 OBSPY_MAPPING
+from mt_metadata.timeseries.filters.filter_base import get_base_obspy_mapping
 from mt_metadata.timeseries.filters.standards import SCHEMA_FN_PATHS
 
 # =============================================================================
@@ -15,14 +14,6 @@ attr_dict.add_dict(get_schema("fir_filter", SCHEMA_FN_PATHS))
 # =============================================================================
 
 
-obspy_mapping = copy.deepcopy(OBSPY_MAPPING)
-# obspy_mapping["_zeros"] = "_zeros"
-obspy_mapping["_symmetry"] = "symmetry"
-obspy_mapping["_coefficients"] = "coefficients"
-obspy_mapping["decimation_factor"] = "decimation_factor"
-obspy_mapping["decimation_input_sample_rate"] = "decimation_input_sample_rate"
-obspy_mapping["stage_gain_frequency"] = "gain_frequency"
-
 
 class FIRFilter(FilterBase):
     """
@@ -39,7 +30,15 @@ class FIRFilter(FilterBase):
         if not self.decimation_factor:
             self.decimation_factor = 1.0
 
-        self.obspy_mapping = obspy_mapping
+
+    def make_obspy_mapping(self):
+        mapping = get_base_obspy_mapping()
+        mapping["_symmetry"] = "symmetry"
+        mapping["_coefficients"] = "coefficients"
+        mapping["decimation_factor"] = "decimation_factor"
+        mapping["decimation_input_sample_rate"] = "decimation_input_sample_rate"
+        mapping["stage_gain_frequency"] = "gain_frequency"
+        return mapping
 
     @property
     def output_sampling_rate(self):

mt_metadata/timeseries/filters/frequency_response_table_filter.py

@@ -1,13 +1,12 @@
 # -*- coding: utf-8 -*-
 """
 .. py:module:: frequency_response_table_filter
-    :synopsis: Deal with frequency look-up tables 
+    :synopsis: Deal with frequency look-up tables
 
 .. codeauthor:: Jared Peacock <jpeacock@usgs.gov>
 .. codeauthor:: Karl Kappler
 
 """
-import copy
 import numpy as np
 from scipy.interpolate import interp1d
 
@@ -18,7 +17,7 @@ from obspy.core.inventory.response import (
 
 from mt_metadata.base import get_schema
 from mt_metadata.timeseries.filters.filter_base import FilterBase
-from mt_metadata.timeseries.filters.filter_base import OBSPY_MAPPING
+from mt_metadata.timeseries.filters.filter_base import get_base_obspy_mapping
 from mt_metadata.timeseries.filters.standards import SCHEMA_FN_PATHS
 
 
@@ -30,10 +29,6 @@ attr_dict.add_dict(
 
 # =============================================================================
 
-obspy_mapping = copy.deepcopy(OBSPY_MAPPING)
-obspy_mapping["amplitudes"] = "_empirical_amplitudes"
-obspy_mapping["frequencies"] = "_empirical_frequencies"
-obspy_mapping["phases"] = "_empirical_phases"
 
 
 class FrequencyResponseTableFilter(FilterBase):
@@ -47,7 +42,13 @@ class FrequencyResponseTableFilter(FilterBase):
 
         super(FilterBase, self).__init__(attr_dict=attr_dict, **kwargs)
         self.type = "frequency response table"
-        self.obspy_mapping = obspy_mapping
+
+    def make_obspy_mapping(self):
+        mapping = get_base_obspy_mapping()
+        mapping["amplitudes"] = "_empirical_amplitudes"
+        mapping["frequencies"] = "_empirical_frequencies"
+        mapping["phases"] = "_empirical_phases"
+        return mapping
 
     @property
     def frequencies(self):

mt_metadata/timeseries/filters/helper_functions.py

@@ -1,5 +1,110 @@
 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 (
+    FrequencyResponseTableFilter,
+)
+
+def make_coefficient_filter(gain=1.0, name="generic coefficient filter", **kwargs):
+    """
+
+    Parameters
+    ----------
+    gain: float
+    name: string
+    units_in : string
+        A supported unit or "unknown"
+        one of "digital counts", "millivolts", etc.
+        A complete list of units can be found in mt_metadata/mt_metadata/util/units.py
+        and is accessible as a table via:
+        from mt_metadata.utils.units import UNITS_DF
+
+    Returns
+    -------
+
+    """
+    # in general, you need to add all required fields from the standards.json
+    default_units_in = "unknown"
+    default_units_out = "unknown"
+
+    cf = CoefficientFilter()
+    cf.gain = gain
+    cf.name = name
+
+    cf.units_in = kwargs.get("units_in", default_units_in)
+    cf.units_out = kwargs.get("units_out", default_units_out)
+
+    return cf
+
+
+def make_frequency_response_table_filter(file_path, case="bf4"):
+    """
+    Parameters
+    ----------
+    filepath: pathlib.Path or string
+    case : string, placeholder for handling different fap table formats.
+
+    Returns
+    -------
+    fap_filter: FrequencyResponseTableFilter
+    """
+    fap_filter = FrequencyResponseTableFilter()
+
+    if case == "bf4":
+        import numpy as np
+        import pandas as pd
+
+        df = pd.read_csv(file_path)  # , skiprows=1)
+        # Hz, V/nT, degrees
+        fap_filter.frequencies = df["Frequency [Hz]"].values
+        fap_filter.amplitudes = df["Amplitude [V/nT]"].values
+        fap_filter.phases = np.deg2rad(df["Phase [degrees]"].values)
+        fap_filter.units_in = "volts"
+        fap_filter.units_out = "nanotesla"
+        fap_filter.gain = 1.0
+        fap_filter.name = "bf4"
+        return fap_filter
+    else:
+        msg = f"Case {case} not supported for FAP Table"
+        logger.error(msg)
+        raise NotImplementedError(msg)
+
+
+def make_volt_per_meter_to_millivolt_per_km_converter():
+    """
+    This represents a filter that converts from mV/km to V/m.
+
+    Returns
+    -------
+
+    """
+    coeff_filter = make_coefficient_filter(
+        gain=1e-6,
+        units_in="millivolts per kilometer",
+        units_out="volts per meter",
+        name="MT to SI electric field conversion",
+    )
+    return coeff_filter
+
+
+def make_tesla_to_nanotesla_converter():
+    """
+    This represents a filter that converts from nt to T.
+
+    Returns
+    -------
+
+    """
+    coeff_filter = make_coefficient_filter(
+        gain=1e-9,
+        units_in="nanotesla",
+        units_out="tesla",
+        name="MT to SI magnetic field conversion",
+    )
+    return coeff_filter
+
+
 
 def decimation_info_is_degenerate(obspy_stage):
     """
@@ -33,6 +138,10 @@ def decimation_info_is_pure_delay(stage):
         return False
 
 
-def stage_gain_is_degenerate():
-    # if gain is 1.0 ignore it
-    pass
+# def stage_gain_is_degenerate():
+#     # if gain is 1.0 ignore it
+#     pass
+
+
+MT2SI_ELECTRIC_FIELD_FILTER = make_volt_per_meter_to_millivolt_per_km_converter()
+MT2SI_MAGNETIC_FIELD_FILTER = make_tesla_to_nanotesla_converter()

mt_metadata/timeseries/filters/pole_zero_filter.py

@@ -1,19 +1,18 @@
 # -*- coding: utf-8 -*-
 """
 .. py:module:: pole_zero_filter
-    :synopsis: Deal with Pole Zero Filters 
+    :synopsis: Deal with Pole Zero Filters
 
 .. codeauthor:: Jared Peacock <jpeacock@usgs.gov>
 
 """
-import copy
 import numpy as np
 import obspy
 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 OBSPY_MAPPING
+from mt_metadata.timeseries.filters.filter_base import get_base_obspy_mapping
 from mt_metadata.timeseries.filters.standards import SCHEMA_FN_PATHS
 
 # =============================================================================
@@ -21,10 +20,6 @@ attr_dict = get_schema("filter_base", SCHEMA_FN_PATHS)
 attr_dict.add_dict(get_schema("pole_zero_filter", SCHEMA_FN_PATHS))
 # =============================================================================
 
-obspy_mapping = copy.deepcopy(OBSPY_MAPPING)
-obspy_mapping["_zeros"] = "zeros"
-obspy_mapping["_poles"] = "poles"
-obspy_mapping["normalization_factor"] = "normalization_factor"
 
 
 class PoleZeroFilter(FilterBase):
@@ -35,7 +30,13 @@ class PoleZeroFilter(FilterBase):
         super(FilterBase, self).__init__(attr_dict=attr_dict, **kwargs)
         self.type = "zpk"
 
-        self.obspy_mapping = obspy_mapping
+
+    def make_obspy_mapping(self):
+        mapping = get_base_obspy_mapping()
+        mapping["_zeros"] = "zeros"
+        mapping["_poles"] = "poles"
+        mapping["normalization_factor"] = "normalization_factor"
+        return mapping
 
     @property
     def poles(self):

mt_metadata/timeseries/filters/standards/filter_base.json

@@ -22,7 +22,7 @@
         "example": "ambient air temperature",
 		"default": null
     },
-	
+
     "type": {
         "type": "string",
         "required": true,
@@ -76,7 +76,7 @@
         "alias": [],
         "example": "2020-01-01",
 		"default": "1980-01-01"
-    }, 
+    },
 
     "gain": {
         "type": "float",

mt_metadata/timeseries/filters/time_delay_filter.py

@@ -8,17 +8,14 @@
 
 """
 
-import copy
 import numpy as np
 from obspy.core import inventory
 
 from mt_metadata.base import get_schema
 from mt_metadata.timeseries.filters.filter_base import FilterBase
-from mt_metadata.timeseries.filters.filter_base import OBSPY_MAPPING
+from mt_metadata.timeseries.filters.filter_base import get_base_obspy_mapping
 from mt_metadata.timeseries.filters.standards import SCHEMA_FN_PATHS
 
-obspy_mapping = copy.deepcopy(OBSPY_MAPPING)
-obspy_mapping["decimation_delay"] = "delay"
 # =============================================================================
 attr_dict = get_schema("filter_base", SCHEMA_FN_PATHS)
 attr_dict.add_dict(get_schema("time_delay_filter", SCHEMA_FN_PATHS))
@@ -32,12 +29,16 @@ class TimeDelayFilter(FilterBase):
         super(FilterBase, self).__init__(attr_dict=attr_dict, **kwargs)
 
         self.type = "time delay"
-        self.obspy_mapping = obspy_mapping
+
+    def make_obspy_mapping(self):
+        mapping = get_base_obspy_mapping()
+        mapping["decimation_delay"] = "delay"
+        return mapping
 
     def to_obspy(self, stage_number=1, sample_rate=1, normalization_frequency=0):
         """
         Convert to an obspy stage
-        
+
         :param stage_number: sequential stage number, defaults to 1
         :type stage_number: integer, optional
         :param normalization_frequency: Normalization frequency, defaults to 1
@@ -45,8 +46,8 @@ class TimeDelayFilter(FilterBase):
         :param sample_rate: sample rate, defaults to 1
         :type sample_rate: float, optional
         :return: Obspy stage filter
-        :rtype: :class:`obspy.core.inventory.CoefficientsTypeResponseStage` 
-        
+        :rtype: :class:`obspy.core.inventory.CoefficientsTypeResponseStage`
+
         """
 
         stage = inventory.CoefficientsTypeResponseStage(

mt_metadata/timeseries/stationxml/fdsn_tools.py

@@ -319,6 +319,11 @@ def read_channel_code(channel_code):
 
 def create_mt_component(channel_code):
     """
+    :param channel_code: Three character string {Period}{Component}{Orientation}
+    :type channel_code: string
+    :return: DESCRIPTION
+    :rtype: TYPE
+
     Create a component for an MT channel given the measurement and orientation
 
     >>> create_mt_component("LQN")
@@ -327,13 +332,9 @@ def create_mt_component(channel_code):
     """
     code_dict = read_channel_code(channel_code)
     if code_dict["measurement"] == "tide":
-        logger.warning(
-            "It is unikely that we have encountered tidal data here"
-        )
-        logger.warning("It is more likely that the channel code 'T' appeared")
-        logger.warning(
-            "Some historial MT data (PKD, SAO) used 'T' as the code for feedback coil magnetometers"
-        )
+        msg = ("Channel code indicates tidal data -- Some historial MT data (PKD, "
+               "SAO) used 'T' as the code for feedback coil magnetometers")
+        logger.warning(msg)
         code_dict = read_channel_code(channel_code.replace("T", "F"))
 
     mt_component = mt_components_dict[code_dict["measurement"]]

mt_metadata/timeseries/stationxml/xml_channel_mt_channel.py

@@ -108,7 +108,7 @@ class XMLChannelMTChannel(BaseTranslator):
 
         # fill channel filters
         mt_channel.filter.name = list(mt_filters.keys())
-        mt_channel.filter.applied = [False] * len(list(mt_filters.keys()))
+        mt_channel.filter.applied = [True] * len(list(mt_filters.keys()))
 
         return mt_channel, mt_filters
 

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/__init__.py

@@ -1,3 +1,3 @@
 from .core import TF
 
-__all__ = ["TF"]
+__all__ = ["TF"]