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

mt_metadata/transfer_functions/io/zfiles/zmm.py

@@ -25,6 +25,7 @@ from mt_metadata.transfer_functions.tf import (
 from mt_metadata.transfer_functions.io.tools import get_nm_elev
 from .metadata import Channel
 from mt_metadata.utils.list_dict import ListDict
+from mt_metadata import DEFAULT_CHANNEL_NOMENCLATURE
 
 # ==============================================================================
 PERIOD_FORMAT = ".10g"
@@ -40,7 +41,6 @@ class ZMMHeader(object):
     """
 
     def __init__(self, fn=None, **kwargs):
-
         self.logger = logger
         self.processing_type = None
         self.num_channels = None
@@ -73,9 +73,7 @@ class ZMMHeader(object):
         if value.suffix.lower() in [".zmm", ".zrr", ".zss"]:
             self._zfn = value
         else:
-            msg = (
-                f"Input file must be a *.zmm or *.zrr file not {value.suffix}"
-            )
+            msg = f"Input file must be a *.zmm or *.zrr file not {value.suffix}"
             self.logger.error(msg)
             raise ValueError(msg)
 
@@ -255,6 +253,15 @@ class ZMMHeader(object):
                 continue
         return lines
 
+    @property
+    def channel_dict(self):
+        channels = {}
+        for cc in ["ex", "ey", "hx", "hy", "hz"]:
+            ch = getattr(self, cc)
+            if ch is not None:
+                channels[cc] = ch.channel
+        return channels
+
     @property
     def channels_recorded(self):
         channels = {}
@@ -293,7 +300,6 @@ class ZMM(ZMMHeader):
     """
 
     def __init__(self, fn=None, **kwargs):
-
         super().__init__()
 
         self.fn = fn
@@ -304,23 +310,7 @@ class ZMM(ZMMHeader):
         self.periods = None
         self.dataset = None
         self.decimation_dict = {}
-        self.channel_nomenclature = {}
-
-        self._ch_input_dict = {
-            "impedance": ["hx", "hy"],
-            "tipper": ["hx", "hy"],
-            "isp": ["hx", "hy"],
-            "res": ["ex", "ey", "hz"],
-            "tf": ["hx", "hy"],
-        }
-
-        self._ch_output_dict = {
-            "impedance": ["ex", "ey"],
-            "tipper": ["hz"],
-            "isp": ["hx", "hy"],
-            "res": ["ex", "ey", "hz"],
-            "tf": ["ex", "ey", "hz"],
-        }
+        self.channel_nomenclature = DEFAULT_CHANNEL_NOMENCLATURE
 
         self._transfer_function = self._initialize_transfer_function()
 
@@ -369,6 +359,78 @@ class ZMM(ZMMHeader):
 
         return f"MT( {(', ').join(lines)} )"
 
+    def __eq__(self, other):
+        """
+        compare equals
+
+        :param other: DESCRIPTION
+        :type other: TYPE
+        :return: DESCRIPTION
+        :rtype: TYPE
+
+        """
+
+        if not isinstance(other, ZMM):
+            raise TypeError(f"Cannot compare type {type(other)} with ZMM.")
+
+        is_equal = True
+        if self.station_metadata != other.station_metadata:
+            is_equal = False
+        if not self.dataset.equals(other.dataset):
+            is_equal = False
+            self.logger.info("Datasets are not equal")
+            print(self.dataset.fillna(0) != other.dataset.fillna(0).all())
+        return is_equal
+
+    @property
+    def channel_nomenclature(self):
+        return self._channel_nomenclature
+
+    @channel_nomenclature.setter
+    def channel_nomenclature(self, ch_dict):
+        """
+        channel dictionary
+        """
+
+        if not isinstance(ch_dict, dict):
+            raise TypeError(
+                "Channel_nomenclature must be a dictionary with keys "
+                "['ex', 'ey', 'hx', 'hy', 'hz']."
+            )
+
+        self._channel_nomenclature = ch_dict
+        # unpack channel nomenclature dict
+        for comp in DEFAULT_CHANNEL_NOMENCLATURE.keys():
+            try:
+                setattr(self, f"_{comp}", ch_dict[comp])
+            except KeyError:
+                setattr(self, f"_{comp}", comp)
+                ch_dict[comp] = comp
+
+        self._ex_ey = [self._ex, self._ey]
+        self._hx_hy = [self._hx, self._hy]
+        self._ex_ey_hz = [self._ex, self._ey, self._hz]
+
+    @property
+    def _ch_input_dict(self):
+        return {
+            "isp": self._hx_hy,
+            "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
+    def _ch_output_dict(self):
+        return {
+            "isp": self._hx_hy,
+            "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],
+        }
+
     def _initialize_transfer_function(self, periods=[1]):
         """
         create an empty x array for the data.  For now this accommodates
@@ -381,45 +443,45 @@ class ZMM(ZMMHeader):
         """
         # 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="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",
         )
@@ -431,7 +493,12 @@ class ZMM(ZMMHeader):
                 tf_err.name: tf_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"],
+            },
         )
 
     @property
@@ -464,7 +531,7 @@ class ZMM(ZMMHeader):
         #    this dimension is hard-coded
         self.sigma_s = np.zeros((self.num_freq, 2, 2), dtype=np.complex64)
 
-    def read(self, fn=None, get_elevation=True):
+    def read(self, fn=None, get_elevation=False):
         """
         Read in Egbert zrr/zmm file
 
@@ -474,24 +541,9 @@ class ZMM(ZMMHeader):
         if fn is not None:
             self.fn = fn
         self.read_header()
+        self.channel_nomenclature = self.channel_dict
         self.initialize_arrays()
 
-        self._ch_input_dict = {
-            "impedance": self.input_channels,
-            "tipper": self.input_channels,
-            "isp": self.input_channels,
-            "res": self.output_channels,
-            "tf": self.input_channels,
-        }
-
-        self._ch_output_dict = {
-            "impedance": ["ex", "ey"],
-            "tipper": ["hz"],
-            "isp": self.input_channels,
-            "res": self.output_channels,
-            "tf": self.output_channels,
-        }
-
         self._transfer_function = self._initialize_transfer_function()
         self.dataset = self._initialize_transfer_function()
 
@@ -649,9 +701,7 @@ class ZMM(ZMMHeader):
              -0.2231E-05 -0.2863E-06  0.8866E-05  0.0000E+00
         """
 
-        period = float(
-            period_block[0].strip().split(":")[1].split()[0].strip()
-        )
+        period = float(period_block[0].strip().split(":")[1].split()[0].strip())
         level = int(
             period_block[0].strip().split("level")[1].split()[0].strip()
         )
@@ -660,12 +710,8 @@ class ZMM(ZMMHeader):
             int(period_block[0].strip().split("to")[1].split()[0].strip()),
         )
 
-        npts = int(
-            period_block[1].strip().split("point")[1].split()[0].strip()
-        )
-        sr = float(
-            period_block[1].strip().split("freq.")[1].split()[0].strip()
-        )
+        npts = int(period_block[1].strip().split("point")[1].split()[0].strip())
+        sr = float(period_block[1].strip().split("freq.")[1].split()[0].strip())
         self.decimation_dict[f"{period:{PERIOD_FORMAT}}"] = {
             "level": level,
             "bands": bands,
@@ -722,7 +768,7 @@ class ZMM(ZMMHeader):
         sig_block = self._flatten_list(sig_block)
         self.sigma_s[index, 0, 0] = sig_block[0]
         self.sigma_s[index, 1, 0] = sig_block[1]
-        self.sigma_s[index, 0, 1] = sig_block[1]
+        self.sigma_s[index, 0, 1] = sig_block[1].conjugate()
         self.sigma_s[index, 1, 1] = sig_block[2]
 
     def _fill_res_array_from_block(self, res_block, index):

mt_metadata/transfer_functions/io/zonge/zonge.py

@@ -28,6 +28,7 @@ from mt_metadata.transfer_functions.tf import (
 )
 from mt_metadata.transfer_functions.io.tools import get_nm_elev
 
+
 # ==============================================================================
 # deal with avg files output from mtedit
 # ==============================================================================
@@ -37,7 +38,6 @@ class ZongeMTAvg:
     """
 
     def __init__(self, fn=None, **kwargs):
-
         self.logger = logger
         self.header = Header()
 
@@ -122,7 +122,7 @@ class ZongeMTAvg:
         else:
             self._fn = None
 
-    def read(self, fn=None, get_elevation=True):
+    def read(self, fn=None, get_elevation=False):
         """
         Read into a pandas data frame
 

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/aurora/channel_nomenclature.py

@@ -25,6 +25,13 @@ STANDARD_OUTPUT_NAMES = [
 ]
 
 def load_channel_maps():
+    """
+    :return: Keys are the channel_nomenclature schema keywords.
+     Values are dictionaries which map the STANDARD_INPUT_NAMES, \
+     STANDARD_OUTPUT_NAMES to the channel names associated with a given
+     channel nomenclature
+    :rtype: dict
+    """
     import json
     import pathlib
     fn = pathlib.Path(__file__).parent.joinpath("standards", "channel_nomenclatures.json")
@@ -35,6 +42,12 @@ def load_channel_maps():
 CHANNEL_MAPS = load_channel_maps()
 
 def get_allowed_channel_names(standard_names):
+    """
+    :param standard_names: one of STANDARD_INPUT_NAMES, or STANDARD_OUTPUT_NAMES
+    :type standard_names: list
+    :return: allowed_names: list of channel names that are supported
+    :rtype: list
+    """
     allowed_names = []
     for ch in standard_names:
         for _, channel_map in CHANNEL_MAPS.items():
@@ -49,25 +62,12 @@ ALLOWED_OUTPUT_CHANNELS = get_allowed_channel_names(STANDARD_OUTPUT_NAMES)
 class ChannelNomenclature(Base):
     __doc__ = write_lines(attr_dict)
 
-    def __init__(self, **kwargs):
-
-        super().__init__(attr_dict=attr_dict, **kwargs)
-        self._keyword = None
-
-    def update_by_keyword(self, keyword):
-        """
-        Assign the HEXY values "ex", "ey" etc based on a pre-defined dict that
-        corresponds to a common use case
-        Parameters
-        ----------
-        keyword
-
-        Returns
-        -------
-
-        """
-        self._update_by_keyword(keyword)
+    def __init__(self, keyword=None):
 
+        super().__init__(attr_dict=attr_dict)
+        self._keyword = keyword
+        if self._keyword is not None:
+            self.update()
 
     @property
     def ex_ey(self):
@@ -100,28 +100,31 @@ class ChannelNomenclature(Base):
     @keyword.setter
     def keyword(self, keyword):
         self._keyword = keyword
-        self._update_by_keyword(keyword)
+        self.update()
 
-    def get_channel_map(self, keyword):
-        if keyword == "default":
+    def get_channel_map(self):
+        if self.keyword == "default":
             channel_map = CHANNEL_MAPS["default"]
-        elif keyword.upper() == "LEMI12":
+        elif self.keyword.upper() == "LEMI12":
             channel_map = CHANNEL_MAPS["lemi12"]
-        elif keyword.upper() == "LEMI34":
+        elif self.keyword.upper() == "LEMI34":
             channel_map = CHANNEL_MAPS["lemi34"]
-        elif keyword.upper() == "NIMS":
+        elif self.keyword.upper() == "NIMS":
             channel_map = CHANNEL_MAPS["default"]
-        elif keyword.upper() == "PHOENIX123":
+        elif self.keyword.upper() == "PHOENIX123":
             channel_map = CHANNEL_MAPS["phoenix123"]
-        elif keyword.upper() == "MUSGRAVES":
+        elif self.keyword.upper() == "MUSGRAVES":
             channel_map = CHANNEL_MAPS["musgraves"]
         else:
-            print(f"whoops mt_system {keyword} unknown")
-            raise NotImplementedError
+            msg = f"channel mt_system {self.keyword} unknown"
+            raise NotImplementedError(msg)
         return channel_map
 
-    def _update_by_keyword(self, keyword):
-        channel_map = self.get_channel_map(keyword)
+    def update(self):
+        """
+        Assign values to standard channel names "ex", "ey" etc based on channel_map dict
+        """
+        channel_map = self.get_channel_map()
         self.ex = channel_map["ex"]
         self.ey = channel_map["ey"]
         self.hx = channel_map["hx"]
@@ -133,5 +136,5 @@ class ChannelNomenclature(Base):
 
     @property
     def channels(self):
-        channels = list(self.get_channel_map(self.keyword).values())
+        channels = list(self.get_channel_map().values())
         return channels

mt_metadata/transfer_functions/processing/aurora/processing.py

@@ -28,7 +28,6 @@ class Processing(Base):
     __doc__ = write_lines(attr_dict)
 
     def __init__(self, **kwargs):
-
         self.stations = Stations()
         self._decimations = []
         self.channel_nomenclature = ChannelNomenclature()
@@ -86,6 +85,12 @@ class Processing(Base):
                         f"List entry must be a DecimationLevel or dict object not {type(obj)}"
                     )
 
+        elif isinstance(value, str):
+            if len(value) > 4:
+                raise TypeError(f"Not sure what to do with {type(value)}")
+            else:
+                self._decimations = []
+
         else:
             raise TypeError(f"Not sure what to do with {type(value)}")
 
@@ -224,7 +229,6 @@ class Processing(Base):
                 decimation_obj.add_band(band)
             self.add_decimation_level(decimation_obj)
 
-
     def json_fn(self):
         json_fn = self.id + "_processing_config.json"
         return json_fn
@@ -280,11 +284,14 @@ class Processing(Base):
         if not self.stations.remote:
             for decimation in self.decimations:
                 if decimation.estimator.engine == "RME_RR":
-                    print("No RR station specified, switching RME_RR to RME")
+                    self.logger.info(
+                        "No RR station specified, switching RME_RR to RME"
+                    )
                     decimation.estimator.engine = "RME"
 
         # Make sure that a local station is defined
         if not self.stations.local.id:
-            print("WARNING: Local station not specified")
-            print("Local station should be set from Kernel Dataset")
+            self.logger.warning(
+                "Local station not specified, should be set from Kernel Dataset"
+            )
             self.stations.from_dataset_dataframe(kernel_dataset.df)

mt_metadata/transfer_functions/processing/aurora/stations.py

@@ -5,6 +5,7 @@ Created on Thu Feb 24 13:58:07 2022
 @author: jpeacock
 """
 import pandas as pd
+
 # =============================================================================
 # Imports
 # =============================================================================
@@ -16,6 +17,7 @@ from .station import Station
 attr_dict = get_schema("stations", SCHEMA_FN_PATHS)
 attr_dict.add_dict(get_schema("station", SCHEMA_FN_PATHS), "local")
 
+
 # =============================================================================
 class Stations(Base):
     """
@@ -66,6 +68,11 @@ class Stations(Base):
         elif isinstance(rr_station, Station):
             rr_station.remote = True
             self._remote.append(rr_station)
+
+        elif isinstance(rr_station, str):
+            if len(rr_station) > 4:
+                raise ValueError(f"not sure to do with {type(rr_station)}")
+
         else:
             raise ValueError(f"not sure to do with {type(rr_station)}")
 
@@ -75,7 +82,9 @@ class Stations(Base):
         """
 
         if not isinstance(rr, (Station, dict)):
-            raise TypeError(f"List entry must be a Station object not {type(rr)}")
+            raise TypeError(
+                f"List entry must be a Station object not {type(rr)}"
+            )
         if isinstance(rr, dict):
             obj = Station()
             obj.from_dict(rr)
@@ -130,7 +139,7 @@ class Stations(Base):
         df = self.local.to_dataset_dataframe()
         for rr in self.remote:
             remote_df = rr.to_dataset_dataframe()
-            df = pd.concat([df, remote_df]) #, axis=1, ignore_index=True)
+            df = pd.concat([df, remote_df])  # , axis=1, ignore_index=True)
 
         df.reset_index(inplace=True, drop=True)
 

mt_metadata/transfer_functions/processing/fourier_coefficients/decimation.py

@@ -320,7 +320,7 @@ class Decimation(Base):
         else:
             required_channels = decimation_level.local_channels
         try:
-            assert set(self.channels_estimated) == set(required_channels)
+            assert set(required_channels).issubset(self.channels_estimated)
         except AssertionError:
             msg = (
                 f"required_channels for processing {required_channels} not available"

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/transfer_functions/processing/fourier_coefficients/standards/fc_channel.json

@@ -9,13 +9,35 @@
         "alias": [],
         "example": "ex",
 		"default": null
+    },
+    "frequency_max": {
+        "type": "float",
+        "required": true,
+        "style": "number",
+        "units": "samples per second",
+        "description": "Highest frequency present in the sprectrogam data.",
+        "options": [],
+        "alias": [],
+        "example": 77.0,
+		"default": 0.0
+    },
+    "frequency_min": {
+        "type": "float",
+        "required": true,
+        "style": "number",
+        "units": "samples per second",
+        "description": "Lowest frequency present in the sprectrogam data.",
+        "options": [],
+        "alias": [],
+        "example": 99.0,
+		"default": 0.0
     },
 	"sample_rate_decimation_level": {
         "type": "float",
         "required": true,
         "style": "number",
         "units": "samples per second",
-        "description": "Sample rate of the decimation level.",
+        "description": "Sample rate of the time series that was Fourier transformed to generate the FC decimation level.",
         "options": [],
         "alias": [],
         "example": 60,