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

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:
@@ -419,8 +419,7 @@ class EDI(object):
                         )
                 elif key.startswith("t"):
                     obj[:, ii, jj] = (
-                        data_dict[f"{key}r.exp"]
-                        + data_dict[f"{key}i.exp"] * 1j
+                        data_dict[f"{key}r.exp"] + data_dict[f"{key}i.exp"] * 1j
                     )
                     try:
                         error_key = [
@@ -756,10 +755,8 @@ class EDI(object):
             extra_lines.append(
                 f"\toriginal_program.date={self.Header.progdate}\n"
             )
-        if self.Header.fileby != "1980-01-01":
-            extra_lines.append(
-                f"\toriginal_file.date={self.Header.filedate}\n"
-            )
+        if self.Header.filedate != "1980-01-01":
+            extra_lines.append(f"\toriginal_file.date={self.Header.filedate}\n")
         header_lines = self.Header.write_header(
             longitude_format=longitude_format, latlon_format=latlon_format
         )
@@ -907,15 +904,11 @@ class EDI(object):
             ]
         elif data_key.lower() == "freq":
             block_lines = [
-                ">{0} // {1:.0f}\n".format(
-                    data_key.upper(), data_comp_arr.size
-                )
+                ">{0} // {1:.0f}\n".format(data_key.upper(), data_comp_arr.size)
             ]
         elif data_key.lower() in ["zrot", "trot"]:
             block_lines = [
-                ">{0} // {1:.0f}\n".format(
-                    data_key.upper(), data_comp_arr.size
-                )
+                ">{0} // {1:.0f}\n".format(data_key.upper(), data_comp_arr.size)
             ]
         else:
             raise ValueError("Cannot write block for {0}".format(data_key))
@@ -1039,6 +1032,13 @@ class EDI(object):
         if survey.summary != None:
             self.Info.info_list.append(f"survey.summary = {survey.summary}")
 
+        for key in survey.to_dict(single=True).keys():
+            if "northwest" in key or "southeast" in key or "time_period" in key:
+                continue
+            value = survey.get_attr_from_name(key)
+            if value != None:
+                self.Info.info_list.append(f"survey.{key} = {value}")
+
     @property
     def station_metadata(self):
         sm = metadata.Station()
@@ -1192,6 +1192,8 @@ class EDI(object):
         self.Header.datum = sm.location.datum
         self.Header.units = sm.transfer_function.units
         self.Header.enddate = sm.time_period.end
+        if sm.geographic_name is not None:
+            self.Header.loc = sm.geographic_name
 
         ### write notes
         # write comments, which would be anything in the info section from an edi
@@ -1203,7 +1205,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}")
@@ -1379,3 +1381,11 @@ class EDI(object):
     @property
     def rrhy_metadata(self):
         return self._get_magnetic_metadata("rrhy")
+
+    @property
+    def rrhx_metadata(self):
+        return self._get_magnetic_metadata("rrhx")
+
+    @property
+    def rrhy_metadata(self):
+        return self._get_magnetic_metadata("rrhy")

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

@@ -441,6 +441,7 @@ class DefineMeasurement(Base):
                     "chtype": channel.component,
                     "id": channel.channel_id,
                     "acqchan": channel.channel_number,
+                    "dip": channel.measurement_tilt,
                 }
             )
             setattr(self, f"meas_{channel.component.lower()}", meas)

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

@@ -17,6 +17,7 @@ from .standards import SCHEMA_FN_PATHS
 # =============================================================================
 attr_dict = get_schema("emeasurement", SCHEMA_FN_PATHS)
 
+
 # ==============================================================================
 # magnetic measurements
 # ==============================================================================
@@ -40,8 +41,9 @@ class EMeasurement(Base):
 
         super().__init__(attr_dict=attr_dict, **kwargs)
 
-        if self.x != 0 or self.y != 0 or self.x2 != 0 or self.y2 != 0:
-            self.azm = self.azimuth
+        if self.azm == 0:
+            if self.x != 0 or self.x2 != 0 or self.y != 0 or self.y2 != 0:
+                self.azm = self.azimuth
 
     def __str__(self):
         return "\n".join(

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

@@ -213,7 +213,7 @@ class Header(Location):
         self,
         longitude_format="LON",
         latlon_format="dms",
-        required=True,
+        required=False,
     ):
         """
         Write header information to a list of lines.
@@ -243,6 +243,8 @@ class Header(Location):
         for key, value in self.to_dict(single=True, required=required).items():
             if key in ["x", "x2", "y", "y2", "z", "z2"]:
                 continue
+            if value in [None, "None"]:
+                continue
             if key in ["latitude"]:
                 key = "lat"
             elif key in ["longitude"]:

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

@@ -10,6 +10,7 @@ Created on Sat Dec  4 14:13:37 2021
 from mt_metadata.base import Base
 from mt_metadata.base.helpers import validate_name
 
+
 # ==============================================================================
 # Info object
 # ==============================================================================
@@ -444,11 +445,17 @@ class Information(Base):
                             new_dict[new_key] = value.split()[0]
                         elif key.lower().endswith("sen"):
                             comp = key.lower().split()[0]
-                            new_dict[
-                                f"{comp}.sensor.manufacturer"
-                            ] = "Phoenix Geophysics"
+                            new_dict[f"{comp}.sensor.manufacturer"] = (
+                                "Phoenix Geophysics"
+                            )
                             new_dict[f"{comp}.sensor.type"] = "Induction Coil"
                             new_dict[new_key] = value
+                        elif new_key in [
+                            "survey.time_period.start_date",
+                            "survey.time_period.end_date",
+                        ]:
+                            if value.count("-") == 1:
+                                new_dict[new_key] = value.split("-")[0]
                         else:
                             new_dict[new_key] = value
 
@@ -461,8 +468,8 @@ class Information(Base):
                 new_dict[key] = value
 
         if processing_parameters != []:
-            new_dict[
-                "transfer_function.processing_parameters"
-            ] = processing_parameters
+            new_dict["transfer_function.processing_parameters"] = (
+                processing_parameters
+            )
 
         self.info_dict = new_dict

mt_metadata/transfer_functions/io/emtfxml/emtfxml.py

@@ -358,14 +358,20 @@ class EMTFXML(emtf_xml.EMTF):
             if hasattr(value, "to_xml") and callable(getattr(value, "to_xml")):
                 if key == "processing_info":
                     if skip_field_notes:
-                        value.remote_info._order.remove("field_notes")
+                        try:
+                            value.remote_info._order.remove("field_notes")
+                        except ValueError:
+                            self.logger.debug("No field notes to skip.")
                     if value.remote_info.site.id in [
                         None,
                         "",
                         "None",
                         "none",
                     ]:
-                        value.remote_info._order.remove("site")
+                        try:
+                            value.remote_info._order.remove("site")
+                        except ValueError:
+                            self.logger.debug("No remote field notes to skip.")
                 element = value.to_xml()
                 if isinstance(element, list):
                     for item in element:
@@ -1211,7 +1217,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 +1233,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 +1241,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 +1249,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/io/emtfxml/metadata/data.py

@@ -432,7 +432,7 @@ class TransferFunction(Base):
                 pass
 
             comp_element = et.SubElement(
-                period_element, key.replace("_", ".").capitalize(), attr_dict
+                period_element, key.replace("_", ".").upper(), attr_dict
             )
             idx_dict = self.write_dict[key]
             shape = arr.shape

mt_metadata/transfer_functions/io/emtfxml/metadata/estimate.py

@@ -56,7 +56,7 @@ class Estimate(Base):
 
         root = et.Element(
             self.__class__.__name__.capitalize(),
-            {"name": self.name, "type": self.type},
+            {"name": self.name.upper(), "type": self.type},
         )
 
         et.SubElement(root, "Description").text = self.description

mt_metadata/transfer_functions/io/emtfxml/metadata/period_range.py

@@ -20,6 +20,8 @@ from mt_metadata.transfer_functions.io.emtfxml.metadata import helpers
 
 # =============================================================================
 attr_dict = get_schema("period_range", SCHEMA_FN_PATHS)
+
+
 # =============================================================================
 class PeriodRange(Base):
     __doc__ = write_lines(attr_dict)
@@ -45,7 +47,10 @@ class PeriodRange(Base):
 
         root = et.Element(
             self.__class__.__name__,
-            {"min": f"{self.min:.9f}", "max": f"{self.max:.9f}"},
+            {
+                "min": f"{self.min:<16.5E}".strip(),
+                "max": f"{self.max:<16.5E}".strip(),
+            },
         )
         if string:
             return element_to_string(root)

mt_metadata/transfer_functions/io/emtfxml/metadata/provenance.py

@@ -11,7 +11,11 @@ Created on Wed Dec 23 21:30:36 2020
 # =============================================================================
 # Imports
 # =============================================================================
-from mt_metadata.base.helpers import write_lines, dict_to_xml, element_to_string
+from mt_metadata.base.helpers import (
+    write_lines,
+    dict_to_xml,
+    element_to_string,
+)
 from mt_metadata.base import get_schema, Base
 from .standards import SCHEMA_FN_PATHS
 from . import Person
@@ -40,7 +44,7 @@ class Provenance(Base):
 
     @property
     def create_time(self):
-        return self._creation_dt.iso_str
+        return self._creation_dt.iso_str.split(".")[0]
 
     @create_time.setter
     def create_time(self, dt_str):

mt_metadata/transfer_functions/io/emtfxml/metadata/standards/copyright.json

@@ -21,7 +21,8 @@
             "Restricted release",
             "Paper Citation Required",
             "Academic Use Only",
-            "Conditions Apply"
+            "Conditions Apply",
+            "Data Citation Required"
         ],
         "alias": [],
         "example": "Unrestricted release",

mt_metadata/transfer_functions/processing/aurora/__init__.py

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