mt-metadata 0.3.4__py2.py3-none-any.whl → 0.3.6__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.6"
 
 # =============================================================================
 # 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/filters/frequency_response_table_filter.py

@@ -30,7 +30,6 @@ attr_dict.add_dict(
 # =============================================================================
 
 
-
 class FrequencyResponseTableFilter(FilterBase):
     """
     Phases should be in radians.
@@ -130,7 +129,6 @@ class FrequencyResponseTableFilter(FilterBase):
             self._empirical_phases = np.array(value, dtype=float)
 
             if self._empirical_phases.size > 0:
-
                 if self._empirical_phases.mean() > 1000 * np.pi / 2:
                     self.logger.warning(
                         "Phases appear to be in milli radians attempting to convert to radians"
@@ -216,12 +214,17 @@ class FrequencyResponseTableFilter(FilterBase):
         :rtype: np.ndarray
 
         """
-        if (
-            np.min(frequencies) < self.min_frequency
-            or np.max(frequencies) > self.max_frequency
-        ):
+        if np.min(frequencies) < self.min_frequency:
+            # if there is a dc component skip it.
+            if np.min(frequencies) != 0:
+                self.logger.warning(
+                    f"Extrapolating frequencies smaller ({np.min(frequencies)} Hz) "
+                    f"than table frequencies ({self.min_frequency} Hz)."
+                )
+        if np.max(frequencies) > self.max_frequency:
             self.logger.warning(
-                "Extrapolating, use values outside calibration frequencies with caution"
+                f"Extrapolating frequencies larger ({np.max(frequencies)} Hz) "
+                f"than table frequencies ({self.max_frequency} Hz)."
             )
 
         phase_response = interp1d(

mt_metadata/timeseries/stationxml/xml_channel_mt_channel.py

@@ -8,6 +8,8 @@ Created on Fri Feb 19 16:14:41 2021
 :license: MIT
 
 """
+import copy
+
 # =============================================================================
 # Imports
 # =============================================================================
@@ -24,6 +26,7 @@ from mt_metadata.timeseries.stationxml.utils import BaseTranslator
 from mt_metadata.utils.units import get_unit_object
 
 from obspy.core import inventory
+from obspy import UTCDateTime
 
 # =============================================================================
 
@@ -33,6 +36,15 @@ class XMLChannelMTChannel(BaseTranslator):
     translate back and forth between StationXML Channel and MT Channel
     """
 
+    understood_sensor_types = [
+        "logger",
+        "magnetometer",
+        "induction coil",
+        "coil",
+        "dipole",
+        "electrode"
+    ]
+
     def __init__(self):
         super().__init__()
 
@@ -109,7 +121,8 @@ class XMLChannelMTChannel(BaseTranslator):
         # fill channel filters
         mt_channel.filter.name = list(mt_filters.keys())
         mt_channel.filter.applied = [True] * len(list(mt_filters.keys()))
-
+        if UTCDateTime(mt_channel.time_period.end) < UTCDateTime(mt_channel.time_period.start):
+            mt_channel.time_period.end = '2200-01-01T00:00:00+00:00'
         return mt_channel, mt_filters
 
     def mt_to_xml(self, mt_channel, filters_dict, hard_code=True):
@@ -217,6 +230,8 @@ class XMLChannelMTChannel(BaseTranslator):
         :rtype: TYPE
 
         """
+        sensor.type = self._deduce_sensor_type(sensor)
+
         if not sensor.type:
             return mt_channel
 
@@ -566,3 +581,40 @@ class XMLChannelMTChannel(BaseTranslator):
         xml_channel.calibration_units_description = unit_obj.name
 
         return xml_channel
+
+
+    def _deduce_sensor_type(self, sensor):
+        """
+
+        :param sensor: Information about a sensor, usually extractes from FDSN XML
+        :type sensor: obspy.core.inventory.util.Equipment
+
+        :return:
+        """
+        original_sensor_type = sensor.type
+        # set sensor_type to be a string if it is None
+        if original_sensor_type is None:
+            sensor_type = ""  # make a string
+            msg = f"Sensor {sensor} does not have field type attr"
+            self.logger.debug(msg)
+        else:
+            sensor_type = copy.deepcopy(original_sensor_type)
+
+        if sensor_type.lower() in self.understood_sensor_types:
+            return sensor_type
+        else:
+            self.logger.warning(f" sensor {sensor} type {sensor.type} not in {self.understood_sensor_types}")
+
+        #  Try handling Bartington FGM at Earthscope ... this is a place holder for handling non-standard cases
+        if sensor.description == "Bartington 3-Axis Fluxgate Sensor":
+            sensor_type = "magnetometer"
+        elif sensor_type.lower() == "bartington":
+            sensor_type = "magnetometer"
+
+
+        # reset sensor_type to None it it was not handled
+        if not sensor_type:
+            sensor_type = original_sensor_type
+            self.logger.error("sensor type could not be resolved")
+
+        return sensor_type

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

@@ -838,10 +838,12 @@ class TF:
         ].data.tolist()
         if self.ex in outputs or self.ey in outputs or self.hz in outputs:
             if np.all(
-                self._transfer_function.transfer_function.sel(
-                    input=self._ch_input_dict["tf"],
-                    output=self._ch_output_dict["tf"],
-                ).data
+                self._transfer_function.transfer_function.loc[
+                    dict(
+                        input=self._ch_input_dict["tf"],
+                        output=self._ch_output_dict["tf"],
+                    )
+                ].data
                 == 0
             ):
                 return False
@@ -857,9 +859,9 @@ class TF:
 
         """
         if self.has_transfer_function():
-            ds = self.dataset.transfer_function.sel(
-                input=self.hx_hy, output=self.ex_ey_hz
-            )
+            ds = self.dataset.transfer_function.loc[
+                dict(input=self.hx_hy, output=self.ex_ey_hz)
+            ]
             for key, mkey in self._dataset_attr_dict.items():
                 obj, attr = mkey.split(".", 1)
                 value = getattr(self, obj).get_attr_from_name(attr)
@@ -889,9 +891,9 @@ class TF:
 
         """
         if self.has_transfer_function():
-            ds = self.dataset.transfer_function_error.sel(
-                input=self.hx_hy, output=self.ex_ey_hz
-            )
+            ds = self.dataset.transfer_function_error.loc[
+                dict(input=self.hx_hy, output=self.ex_ey_hz)
+            ]
             for key, mkey in self._dataset_attr_dict.items():
                 obj, attr = mkey.split(".", 1)
                 value = getattr(self, obj).get_attr_from_name(attr)
@@ -921,9 +923,9 @@ class TF:
 
         """
         if self.has_transfer_function():
-            ds = self.dataset.transfer_function_model_error.sel(
-                input=self.hx_hy, output=self.ex_ey_hz
-            )
+            ds = self.dataset.transfer_function_model_error.loc[
+                dict(input=self.hx_hy, output=self.ex_ey_hz)
+            ]
             for key, mkey in self._dataset_attr_dict.items():
                 obj, attr = mkey.split(".", 1)
                 value = getattr(self, obj).get_attr_from_name(attr)
@@ -958,10 +960,12 @@ class TF:
         ].data.tolist()
         if self.ex in outputs or self.ey in outputs:
             if np.all(
-                self._transfer_function.transfer_function.sel(
-                    input=self._ch_input_dict["impedance"],
-                    output=self._ch_output_dict["impedance"],
-                ).data
+                self._transfer_function.transfer_function.loc[
+                    dict(
+                        input=self._ch_input_dict["impedance"],
+                        output=self._ch_output_dict["impedance"],
+                    )
+                ].data
                 == 0
             ):
                 return False
@@ -977,10 +981,12 @@ class TF:
 
         """
         if self.has_impedance():
-            z = self.dataset.transfer_function.sel(
-                input=self._ch_input_dict["impedance"],
-                output=self._ch_output_dict["impedance"],
-            )
+            z = self.dataset.transfer_function.loc[
+                dict(
+                    input=self._ch_input_dict["impedance"],
+                    output=self._ch_output_dict["impedance"],
+                )
+            ]
             z.name = "impedance"
             for key, mkey in self._dataset_attr_dict.items():
                 obj, attr = mkey.split(".", 1)
@@ -1011,10 +1017,12 @@ class TF:
 
         """
         if self.has_impedance():
-            z_err = self.dataset.transfer_function_error.sel(
-                input=self._ch_input_dict["impedance"],
-                output=self._ch_output_dict["impedance"],
-            )
+            z_err = self.dataset.transfer_function_error.loc[
+                dict(
+                    input=self._ch_input_dict["impedance"],
+                    output=self._ch_output_dict["impedance"],
+                )
+            ]
             z_err.name = "impedance_error"
 
             for key, mkey in self._dataset_attr_dict.items():
@@ -1046,10 +1054,12 @@ class TF:
 
         """
         if self.has_impedance():
-            z_err = self.dataset.transfer_function_model_error.sel(
-                input=self._ch_input_dict["impedance"],
-                output=self._ch_output_dict["impedance"],
-            )
+            z_err = self.dataset.transfer_function_model_error.loc[
+                dict(
+                    input=self._ch_input_dict["impedance"],
+                    output=self._ch_output_dict["impedance"],
+                )
+            ]
             z_err.name = "impedance_model_error"
 
             for key, mkey in self._dataset_attr_dict.items():
@@ -1087,10 +1097,12 @@ class TF:
         if self.hz in outputs:
             if np.all(
                 np.nan_to_num(
-                    self._transfer_function.transfer_function.sel(
-                        input=self._ch_input_dict["tipper"],
-                        output=self._ch_output_dict["tipper"],
-                    ).data
+                    self._transfer_function.transfer_function.loc[
+                        dict(
+                            input=self._ch_input_dict["tipper"],
+                            output=self._ch_output_dict["tipper"],
+                        )
+                    ].data
                 )
                 == 0
             ):
@@ -1107,10 +1119,12 @@ class TF:
 
         """
         if self.has_tipper():
-            t = self.dataset.transfer_function.sel(
-                input=self._ch_input_dict["tipper"],
-                output=self._ch_output_dict["tipper"],
-            )
+            t = self.dataset.transfer_function.loc[
+                dict(
+                    input=self._ch_input_dict["tipper"],
+                    output=self._ch_output_dict["tipper"],
+                )
+            ]
             t.name = "tipper"
 
             for key, mkey in self._dataset_attr_dict.items():
@@ -1141,10 +1155,12 @@ class TF:
 
         """
         if self.has_tipper():
-            t = self.dataset.transfer_function_error.sel(
-                input=self._ch_input_dict["tipper"],
-                output=self._ch_output_dict["tipper"],
-            )
+            t = self.dataset.transfer_function_error.loc[
+                dict(
+                    input=self._ch_input_dict["tipper"],
+                    output=self._ch_output_dict["tipper"],
+                )
+            ]
             t.name = "tipper_error"
             for key, mkey in self._dataset_attr_dict.items():
                 obj, attr = mkey.split(".", 1)
@@ -1174,10 +1190,12 @@ class TF:
 
         """
         if self.has_tipper():
-            t = self.dataset.transfer_function_model_error.sel(
-                input=self._ch_input_dict["tipper"],
-                output=self._ch_output_dict["tipper"],
-            )
+            t = self.dataset.transfer_function_model_error.loc[
+                dict(
+                    input=self._ch_input_dict["tipper"],
+                    output=self._ch_output_dict["tipper"],
+                )
+            ]
             t.name = "tipper_model_error"
             for key, mkey in self._dataset_attr_dict.items():
                 obj, attr = mkey.split(".", 1)
@@ -1209,10 +1227,12 @@ class TF:
         """
 
         if np.all(
-            self._transfer_function.inverse_signal_power.sel(
-                input=self._ch_input_dict["isp"],
-                output=self._ch_output_dict["isp"],
-            ).data
+            self._transfer_function.inverse_signal_power.loc[
+                dict(
+                    input=self._ch_input_dict["isp"],
+                    output=self._ch_output_dict["isp"],
+                )
+            ].data
             == 0
         ):
             return False
@@ -1221,10 +1241,12 @@ class TF:
     @property
     def inverse_signal_power(self):
         if self.has_inverse_signal_power():
-            ds = self.dataset.inverse_signal_power.sel(
-                input=self._ch_input_dict["isp"],
-                output=self._ch_output_dict["isp"],
-            )
+            ds = self.dataset.inverse_signal_power.loc[
+                dict(
+                    input=self._ch_input_dict["isp"],
+                    output=self._ch_output_dict["isp"],
+                )
+            ]
             for key, mkey in self._dataset_attr_dict.items():
                 obj, attr = mkey.split(".", 1)
                 value = getattr(self, obj).get_attr_from_name(attr)
@@ -1260,10 +1282,12 @@ class TF:
         """
 
         if np.all(
-            self._transfer_function.residual_covariance.sel(
-                input=self._ch_input_dict["res"],
-                output=self._ch_output_dict["res"],
-            ).data
+            self._transfer_function.residual_covariance.loc[
+                dict(
+                    input=self._ch_input_dict["res"],
+                    output=self._ch_output_dict["res"],
+                )
+            ].data
             == 0
         ):
             return False
@@ -1272,10 +1296,12 @@ class TF:
     @property
     def residual_covariance(self):
         if self.has_residual_covariance():
-            ds = self.dataset.residual_covariance.sel(
-                input=self._ch_input_dict["res"],
-                output=self._ch_output_dict["res"],
-            )
+            ds = self.dataset.residual_covariance.loc[
+                dict(
+                    input=self._ch_input_dict["res"],
+                    output=self._ch_output_dict["res"],
+                )
+            ]
             for key, mkey in self._dataset_attr_dict.items():
                 obj, attr = mkey.split(".", 1)
                 value = getattr(self, obj).get_attr_from_name(attr)
@@ -2222,19 +2248,19 @@ class TF:
             setattr(self, tf_key, getattr(zmm_obj, j_key))
         self._transfer_function["transfer_function"].loc[
             dict(input=zmm_obj.input_channels, output=zmm_obj.output_channels)
-        ] = zmm_obj.dataset.transfer_function.sel(
-            input=zmm_obj.input_channels, output=zmm_obj.output_channels
-        )
+        ] = zmm_obj.dataset.transfer_function.loc[
+            dict(input=zmm_obj.input_channels, output=zmm_obj.output_channels)
+        ]
         self._transfer_function["inverse_signal_power"].loc[
             dict(input=zmm_obj.input_channels, output=zmm_obj.input_channels)
-        ] = zmm_obj.dataset.inverse_signal_power.sel(
-            input=zmm_obj.input_channels, output=zmm_obj.input_channels
-        )
+        ] = zmm_obj.dataset.inverse_signal_power.loc[
+            dict(input=zmm_obj.input_channels, output=zmm_obj.input_channels)
+        ]
         self._transfer_function["residual_covariance"].loc[
             dict(input=zmm_obj.output_channels, output=zmm_obj.output_channels)
-        ] = zmm_obj.dataset.residual_covariance.sel(
-            input=zmm_obj.output_channels, output=zmm_obj.output_channels
-        )
+        ] = zmm_obj.dataset.residual_covariance.loc[
+            dict(input=zmm_obj.output_channels, output=zmm_obj.output_channels)
+        ]
 
         self._compute_error_from_covariance()
         self._rotation_angle = -1 * zmm_obj.declination
@@ -2362,4 +2388,3 @@ class TF:
 
 class TFError(Exception):
     pass
-    pass

mt_metadata/transfer_functions/io/edi/edi.py

@@ -300,20 +300,20 @@ class EDI(object):
 
         self._read_data()
 
-        if self.Header.lat is None:
+        if self.Header.lat in [None, 0.0]:
             self.Header.lat = self.Measurement.reflat
             self.logger.debug(
-                "Got latitude from reflat for {0}".format(self.Header.dataid)
+                f"Got latitude from reflat for {self.Header.dataid}"
             )
-        if self.Header.lon is None:
+        if self.Header.lon in [None, 0.0]:
             self.Header.lon = self.Measurement.reflon
             self.logger.debug(
-                "Got longitude from reflon for {0}".format(self.Header.dataid)
+                f"Got longitude from reflon for {self.Header.dataid}"
             )
-        if self.Header.elev is None:
+        if self.Header.elev in [None, 0.0]:
             self.Header.elev = self.Measurement.refelev
             self.logger.debug(
-                "Got elevation from refelev for {0}".format(self.Header.dataid)
+                f"Got elevation from refelev for {self.Header.dataid}"
             )
 
         if self.elev in [0, None] and get_elevation:
@@ -1203,7 +1203,7 @@ class EDI(object):
                 if k in ["processing_parameters"]:
                     for item in v:
                         self.Info.info_list.append(
-                            f"transfer_function.{item.replace('=', ' = ')}"
+                            f"transfer_function.processing_parameters.{item.replace('=', ' = ')}"
                         )
                 else:
                     self.Info.info_list.append(f"transfer_function.{k} = {v}")

mt_metadata/transfer_functions/io/emtfxml/emtfxml.py

@@ -1211,7 +1211,7 @@ class EMTFXML(emtf_xml.EMTF):
                                 self.logger.warning(
                                     f"Cannot set processing info attribute {param}"
                                 )
-                                self.logger.exception(error)
+                                # self.logger.exception(error)
                         elif "magnetometer" in key:
                             index = int(key.split("_")[1].split(".")[0])
                             key = key.split(".", 1)[1:]
@@ -1227,7 +1227,7 @@ class EMTFXML(emtf_xml.EMTF):
                                 self.logger.warning(
                                     f"Cannot set processing info attribute {param}"
                                 )
-                                self.logger.exception(error)
+                                # self.logger.exception(error)
                         else:
                             try:
                                 run.set_attr_from_name(key, value)
@@ -1235,7 +1235,7 @@ class EMTFXML(emtf_xml.EMTF):
                                 self.logger.warning(
                                     f"Cannot set processing info attribute {param}"
                                 )
-                                self.logger.exception(error)
+                                # self.logger.exception(error)
                     else:
                         try:
                             self.processing_info.set_attr_from_name(key, value)
@@ -1243,7 +1243,7 @@ class EMTFXML(emtf_xml.EMTF):
                             self.logger.warning(
                                 f"Cannot set processing info attribute {param}"
                             )
-                            self.logger.exception(error)
+                            # self.logger.exception(error)
 
         self.site.run_list = sm.transfer_function.runs_processed
 

mt_metadata/transfer_functions/processing/aurora/__init__.py

@@ -20,7 +20,6 @@ __all__ = [
     "Decimation",
     "DecimationLevel",
     "Estimator",
-    "FrequencyBand",
     "Processing",
     "Regression",
     "Run",