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

mt_metadata/transfer_functions/core.py

@@ -36,14 +36,8 @@ from mt_metadata.transfer_functions.io.zfiles.metadata import (
 )
 from mt_metadata.base.helpers import validate_name
 from mt_metadata.utils.list_dict import ListDict
+from mt_metadata import DEFAULT_CHANNEL_NOMENCLATURE
 
-DEFAULT_CHANNEL_NOMENCLATURE = {
-    "hx": "hx",
-    "hy": "hy",
-    "hz": "hz",
-    "ex": "ex",
-    "ey": "ey",
-}
 # =============================================================================
 
 
@@ -102,10 +96,29 @@ class TF:
             "avg": {"write": self.to_avg, "read": self.from_avg},
         }
 
+        tf_set = False
+        try:
+            period = kwargs.pop("period")
+            self._transfer_function = self._initialize_transfer_function(
+                periods=period
+            )
+            tf_set = True
+        except KeyError:
+            try:
+                period = 1.0 / kwargs.pop("frequency")
+                self._transfer_function = self._initialize_transfer_function(
+                    periods=period
+                )
+                tf_set = True
+            except KeyError:
+                pass
+            pass
+
         for key, value in kwargs.items():
             setattr(self, key, value)
 
-        self._transfer_function = self._initialize_transfer_function()
+        if not tf_set:
+            self._transfer_function = self._initialize_transfer_function()
 
         self.fn = fn
 
@@ -178,10 +191,7 @@ class TF:
             self.logger.info("Survey Metadata is not equal")
             is_equal = False
         if self.has_transfer_function() and other.has_transfer_function():
-            if (
-                self.transfer_function.fillna(0)
-                != other.transfer_function.fillna(0)
-            ).any():
+            if not self.transfer_function.equals(other.transfer_function):
                 self.logger.info("TF is not equal")
                 is_equal = False
         elif (
@@ -204,6 +214,7 @@ class TF:
                 continue
 
             setattr(result, k, deepcopy(v, memo))
+        result.logger = logger
         return result
 
     def copy(self):
@@ -434,56 +445,56 @@ class TF:
         """
         # create an empty array for the transfer function
         tf = xr.DataArray(
-            data=0 + 0j,
+            data=0.0 + 0j,
             dims=["period", "output", "input"],
             coords={
                 "period": periods,
-                "output": self._ch_output_dict["tf"],
-                "input": self._ch_input_dict["tf"],
+                "output": self._ch_output_dict["all"],
+                "input": self._ch_input_dict["all"],
             },
             name="transfer_function",
         )
 
         tf_err = xr.DataArray(
-            data=0,
+            data=0.0,
             dims=["period", "output", "input"],
             coords={
                 "period": periods,
-                "output": self._ch_output_dict["tf"],
-                "input": self._ch_input_dict["tf"],
+                "output": self._ch_output_dict["all"],
+                "input": self._ch_input_dict["all"],
             },
             name="transfer_function_error",
         )
 
         tf_model_err = xr.DataArray(
-            data=0,
+            data=0.0,
             dims=["period", "output", "input"],
             coords={
                 "period": periods,
-                "output": self._ch_output_dict["tf"],
-                "input": self._ch_input_dict["tf"],
+                "output": self._ch_output_dict["all"],
+                "input": self._ch_input_dict["all"],
             },
             name="transfer_function_model_error",
         )
 
         inv_signal_power = xr.DataArray(
-            data=0 + 0j,
+            data=0.0 + 0j,
             dims=["period", "output", "input"],
             coords={
                 "period": periods,
-                "output": self._ch_output_dict["isp"],
-                "input": self._ch_input_dict["isp"],
+                "output": self._ch_output_dict["all"],
+                "input": self._ch_input_dict["all"],
             },
             name="inverse_signal_power",
         )
 
         residual_covariance = xr.DataArray(
-            data=0 + 0j,
+            data=0.0 + 0j,
             dims=["period", "output", "input"],
             coords={
                 "period": periods,
-                "output": self._ch_output_dict["res"],
-                "input": self._ch_input_dict["res"],
+                "output": self._ch_output_dict["all"],
+                "input": self._ch_input_dict["all"],
             },
             name="residual_covariance",
         )
@@ -496,7 +507,12 @@ class TF:
                 tf_model_err.name: tf_model_err,
                 inv_signal_power.name: inv_signal_power,
                 residual_covariance.name: residual_covariance,
-            }
+            },
+            coords={
+                "period": periods,
+                "output": self._ch_output_dict["all"],
+                "input": self._ch_input_dict["all"],
+            },
         )
 
     # ==========================================================================
@@ -531,7 +547,6 @@ class TF:
 
     @property
     def _ch_input_dict(self):
-
         return {
             "impedance": self.hx_hy,
             "tipper": self.hx_hy,
@@ -543,6 +558,7 @@ class TF:
             "res": self.ex_ey_hz,
             "tf": self.hx_hy,
             "tf_error": self.hx_hy,
+            "all": [self.ex, self.ey, self.hz, self.hx, self.hy],
         }
 
     @property
@@ -558,8 +574,33 @@ class TF:
             "res": self.ex_ey_hz,
             "tf": self.ex_ey_hz,
             "tf_error": self.ex_ey_hz,
+            "all": [self.ex, self.ey, self.hz, self.hx, self.hy],
         }
 
+    @property
+    def index_zxx(self):
+        return {"input": self.hx, "output": self.ex}
+
+    @property
+    def index_zxy(self):
+        return {"input": self.hy, "output": self.ex}
+
+    @property
+    def index_zyx(self):
+        return {"input": self.hx, "output": self.ey}
+
+    @property
+    def index_zyy(self):
+        return {"input": self.hy, "output": self.ey}
+
+    @property
+    def index_tzx(self):
+        return {"input": self.hx, "output": self.hz}
+
+    @property
+    def index_tzy(self):
+        return {"input": self.hy, "output": self.hz}
+
     @property
     def fn(self):
         """reference to original data file"""
@@ -1278,25 +1319,25 @@ class TF:
         ]
 
         z_err = np.zeros((self.period.size, 2, 2), dtype=float)
-        z_err[:, 0, 0] = np.real(
+        z_err[:, 0, 0] = np.abs(
             sigma_e.loc[dict(input=[self.ex], output=[self.ex])].data.flatten()
             * sigma_s.loc[
                 dict(input=[self.hx], output=[self.hx])
             ].data.flatten()
         )
-        z_err[:, 0, 1] = np.real(
+        z_err[:, 0, 1] = np.abs(
             sigma_e.loc[dict(input=[self.ex], output=[self.ex])].data.flatten()
             * sigma_s.loc[
                 dict(input=[self.hy], output=[self.hy])
             ].data.flatten()
         )
-        z_err[:, 1, 0] = np.real(
+        z_err[:, 1, 0] = np.abs(
             sigma_e.loc[dict(input=[self.ey], output=[self.ey])].data.flatten()
             * sigma_s.loc[
                 dict(input=[self.hx], output=[self.hx])
             ].data.flatten()
         )
-        z_err[:, 1, 1] = np.real(
+        z_err[:, 1, 1] = np.abs(
             sigma_e.loc[dict(input=[self.ey], output=[self.ey])].data.flatten()
             * sigma_s.loc[
                 dict(input=[self.hy], output=[self.hy])
@@ -1329,13 +1370,13 @@ class TF:
         ]
 
         t_err = np.zeros((self.period.size, 1, 2), dtype=float)
-        t_err[:, 0, 0] = np.real(
+        t_err[:, 0, 0] = np.abs(
             sigma_e.loc[dict(input=[self.hz], output=[self.hz])].data.flatten()
             * sigma_s.loc[
                 dict(input=[self.hx], output=[self.hx])
             ].data.flatten()
         )
-        t_err[:, 0, 1] = np.real(
+        t_err[:, 0, 1] = np.abs(
             sigma_e.loc[dict(input=[self.hz], output=[self.hz])].data.flatten()
             * sigma_s.loc[
                 dict(input=[self.hy], output=[self.hy])
@@ -1366,11 +1407,11 @@ class TF:
     @period.setter
     def period(self, value):
         if self.period is not None:
-            if len(self.period) == 1 and self.period == np.array([1]):
+            if len(self.period) == 1 and (self.period == np.array([1])).all():
                 self._transfer_function = self._initialize_transfer_function(
                     periods=value
                 )
-            if len(value) != len(self.period):
+            elif len(value) != len(self.period):
                 msg = (
                     f"New period size {value.size} is not the same size as "
                     f"old ones {self.period.size}, suggest creating a new "
@@ -1378,7 +1419,7 @@ class TF:
                 )
                 self.logger.error(msg)
                 raise TFError(msg)
-            else:
+            elif not (self.period == value).all():
                 self.dataset["period"] = value
         else:
             self._transfer_function = self._initialize_transfer_function(
@@ -1596,7 +1637,6 @@ class TF:
                     period_slice["period"].start is not None
                     and period_slice["period"].stop is not None
                 ):
-
                     return tf._transfer_function.where(
                         (
                             tf._transfer_function.period
@@ -1734,7 +1774,7 @@ class TF:
     def read_tf_file(self, **kwargs):
         self.logger.error("'read_tf_file' has been deprecated use 'read()'")
 
-    def read(self, fn=None, file_type=None, get_elevation=True, **kwargs):
+    def read(self, fn=None, file_type=None, get_elevation=False, **kwargs):
         """
 
         Read an TF response file.
@@ -1840,7 +1880,7 @@ class TF:
 
         return edi_obj
 
-    def from_edi(self, edi_obj, get_elevation=True, **kwargs):
+    def from_edi(self, edi_obj, get_elevation=False, **kwargs):
         """
         Read in an EDI file or a
         :class:`mt_metadata.transfer_functions.io.edi.EDI` ojbect
@@ -1863,14 +1903,14 @@ class TF:
             edi_obj.read(self._fn, get_elevation=get_elevation)
         if not isinstance(edi_obj, EDI):
             raise TypeError(f"Input must be a EDI object not {type(edi_obj)}")
-        if edi_obj.tf is not None:
+        if edi_obj.tf is not None and edi_obj.tf.shape[1:] == (3, 2):
             k_dict = OrderedDict(
                 {
                     "period": "period",
                     "transfer_function": "tf",
-                    "transfer_function_error": "tf_err",
                     "inverse_signal_power": "signal_inverse_power",
                     "residual_covariance": "residual_covariance",
+                    "transfer_function_error": "tf_err",
                     "survey_metadata": "survey_metadata",
                     "station_metadata": "station_metadata",
                 }
@@ -1958,7 +1998,7 @@ class TF:
 
         return emtf
 
-    def from_emtfxml(self, emtfxml_obj, get_elevation=True, **kwargs):
+    def from_emtfxml(self, emtfxml_obj, get_elevation=False, **kwargs):
         """
 
         :param emtfxml_object: path to emtf xml file or EMTFXML object
@@ -2016,7 +2056,7 @@ class TF:
 
         raise IOError("to_jfile not implemented yet.")
 
-    def from_jfile(self, j_obj, get_elevation=True, **kwargs):
+    def from_jfile(self, j_obj, get_elevation=False, **kwargs):
         """
 
         :param jfile_obj: path ot .j file or JFile object
@@ -2149,7 +2189,7 @@ class TF:
 
         return zmm_obj
 
-    def from_zmm(self, zmm_obj, get_elevation=True, **kwargs):
+    def from_zmm(self, zmm_obj, get_elevation=False, **kwargs):
         """
 
         :param zmm_obj: path ot .zmm file or ZMM object
@@ -2218,7 +2258,7 @@ class TF:
         """
         return self.to_zmm()
 
-    def from_zrr(self, zrr_obj, get_elevation=True, **kwargs):
+    def from_zrr(self, zrr_obj, get_elevation=False, **kwargs):
         """
 
         :param zmm_obj: path ot .zmm file or ZMM object
@@ -2253,7 +2293,7 @@ class TF:
         """
         return self.to_zmm()
 
-    def from_zss(self, zss_obj, get_elevation=True, **kwargs):
+    def from_zss(self, zss_obj, get_elevation=False, **kwargs):
         """
 
         :param zmm_obj: path to .zmm file or ZMM object
@@ -2284,7 +2324,7 @@ class TF:
 
         raise AttributeError("to_avg does not exist yet.")
 
-    def from_avg(self, avg_obj, get_elevation=True, **kwargs):
+    def from_avg(self, avg_obj, get_elevation=False, **kwargs):
         """
 
         :param avg_obj: path to .avg file or ZongeMTAvg object

mt_metadata/transfer_functions/io/edi/edi.py

@@ -35,6 +35,7 @@ from mt_metadata.transfer_functions.io.tools import (
 
 from mt_metadata import __version__
 
+
 # ==============================================================================
 # EDI Class
 # ==============================================================================
@@ -251,7 +252,7 @@ class EDI(object):
             return 1.0 / self.frequency
         return None
 
-    def read(self, fn=None, get_elevation=True):
+    def read(self, fn=None, get_elevation=False):
         """
         Read in an edi file and fill attributes of each section's classes.
         Including:
@@ -672,10 +673,13 @@ class EDI(object):
                 + np.matmul(tf, np.matmul(hh, tfh))
             ) / avgt_dict[key]
 
+            # variance = abs(np.dot(res[0 : cc.n_inputs, :].T, sig))
             variance = np.zeros((cc.n_outputs, cc.n_inputs), dtype=complex)
             for nn in range(cc.n_outputs):
                 for mm in range(cc.n_inputs):
                     variance[nn, mm] = res[nn, nn] * sig[mm, mm]
+
+            tf_err = np.sqrt(np.abs(variance))
             self.tf[kk, :, :] = tf
             self.tf_err[kk, :, :] = np.sqrt(np.abs(variance))
             self.signal_inverse_power[kk, :, :] = sig
@@ -683,18 +687,18 @@ class EDI(object):
 
             if cc.has_tipper and cc.has_electric:
                 self.z[kk, :, :] = tf[0:2, :]
-                self.z_err[kk, :, :] = np.sqrt(np.abs(variance[0:2, :]))
+                self.z_err[kk, :, :] = tf_err[0:2, :]
                 self.t[kk, :, :] = tf[2, :]
-                self.t_err[kk, :, :] = np.sqrt(np.abs(variance[2, :].real))
+                self.t_err[kk, :, :] = tf_err[2, :]
                 self.z_err[np.where(np.nan_to_num(self.z_err) == 0.0)] = 1.0
                 self.t_err[np.nan_to_num(self.t_err) == 0.0] = 1.0
             elif not cc.has_tipper and cc.has_electric:
                 self.z[kk, :, :] = tf[:, :]
-                self.z_err[kk, :, :] = np.sqrt(np.abs(variance[:, :]))
+                self.z_err[kk, :, :] = tf_err[:, :]
                 self.z_err[np.where(np.nan_to_num(self.z_err) == 0.0)] = 1.0
             elif cc.has_tipper and not cc.has_electric:
                 self.t[kk, :, :] = tf[:, :]
-                self.t_err[kk, :, :] = np.sqrt(np.abs(variance[:, :].real))
+                self.t_err[kk, :, :] = tf_err[:, :]
                 self.t_err[np.nan_to_num(self.t_err) == 0.0] = 1.0
 
     def write(

mt_metadata/transfer_functions/io/edi/metadata/define_measurement.py

@@ -192,7 +192,7 @@ class DefineMeasurement(Base):
                 meas_find = True
             elif ">=" in line:
                 if meas_find is True:
-                    break
+                    return
             elif meas_find is True and ">" not in line:
                 line = line.strip()
                 if len(line) > 2:
@@ -210,7 +210,7 @@ class DefineMeasurement(Base):
             elif ">" in line and meas_find:
                 if line.find("!") > 0:
                     pass
-                else:
+                elif "meas" in line.lower():
                     count += 1
                     line_list = _validate_str_with_equals(line)
                     m_dict = {}
@@ -220,6 +220,8 @@ class DefineMeasurement(Base):
                         value = ll_list[1]
                         m_dict[key] = value
                     self.measurement_list.append(m_dict)
+                else:
+                    return
 
     def read_measurement(self, edi_lines):
         """
@@ -292,7 +294,9 @@ class DefineMeasurement(Base):
                         value.azm = value.azimuth
                 if hasattr(self, key):
                     existing_ch = getattr(self, key)
-                    if value != existing_ch:
+                    existing_line = existing_ch.write_meas_line()
+                    value_line = value.write_meas_line()
+                    if existing_line != value_line:
                         value.chtype = f"rr{ch_type}".upper()
                         key = f"meas_rr{ch_type}"
                     else:

mt_metadata/transfer_functions/io/emtfxml/emtfxml.py

@@ -273,7 +273,7 @@ class EMTFXML(emtf_xml.EMTF):
             return self.fn.parent
         return None
 
-    def read(self, fn=None, get_elevation=True):
+    def read(self, fn=None, get_elevation=False):
         """
         Read xml file
 
@@ -377,7 +377,6 @@ class EMTFXML(emtf_xml.EMTF):
                         emtf_helpers._convert_tag_to_capwords(element)
                     )
             else:
-
                 emtf_helpers._write_single(
                     emtf_element, key, getattr(self, key)
                 )
@@ -654,7 +653,6 @@ class EMTFXML(emtf_xml.EMTF):
                 value,
             )
         elif fkey in ["x", "y", "z"]:
-
             if comp in ["hx", "hy"]:
                 if len(self.site_layout.output_channels) == 0:
                     self.site_layout.input_channels.append(
@@ -1231,7 +1229,6 @@ class EMTFXML(emtf_xml.EMTF):
                                 )
                                 self.logger.exception(error)
                         else:
-
                             try:
                                 run.set_attr_from_name(key, value)
                             except Exception as error:

mt_metadata/transfer_functions/io/jfiles/jfile.py

@@ -23,6 +23,7 @@ from mt_metadata.utils.mttime import MTime
 from .metadata import Header
 from mt_metadata.transfer_functions.io.tools import get_nm_elev
 
+
 # ==============================================================================
 # Class to read j_file
 # ==============================================================================
@@ -161,7 +162,7 @@ class JFile:
 
         return j_lines
 
-    def read(self, fn=None, get_elevation=True):
+    def read(self, fn=None, get_elevation=False):
         """
         Read data from a j file