mt-metadata 0.3.9__py2.py3-none-any.whl → 0.4.0__py2.py3-none-any.whl

mt_metadata/transfer_functions/io/zonge/zonge.py

@@ -156,9 +156,7 @@ class ZongeMTAvg:
                 entry = dict(
                     [
                         (key.lower(), value)
-                        for key, value in zip(
-                            ["comp"] + self.info_keys, values
-                        )
+                        for key, value in zip(["comp"] + self.info_keys, values)
                     ]
                 )
                 data_list.append(entry)
@@ -247,9 +245,7 @@ class ZongeMTAvg:
 
             z[f_index, ii, jj] = z_real + 1j * z_imag
 
-            z_err[f_index, ii, jj] = np.sqrt(
-                z_real_error**2 + z_imag_error**2
-            )
+            z_err[f_index, ii, jj] = np.sqrt(z_real_error**2 + z_imag_error**2)
 
         return z, z_err
 
@@ -304,13 +300,13 @@ class ZongeMTAvg:
         if self.header.start_time is not None:
             rm.time_period.start = self.header.start_time
 
-        if "zxy" in self.components:
+        if "zxy" in self.components or "zxxr" in self.components:
             rm.add_channel(self.ex_metadata)
             rm.add_channel(self.ey_metadata)
             rm.add_channel(self.hx_metadata)
             rm.add_channel(self.hy_metadata)
 
-        if "tzx" in self.components:
+        if "tzx" in self.components or "rxxr" in self.components:
             rm.add_channel(self.hz_metadata)
 
         return rm
@@ -323,9 +319,9 @@ class ZongeMTAvg:
             ch.measurement_azimuth = self.header._comp_dict["zxy"][
                 "ch"
             ].azimuth[0]
-            ch.translated_azimuth = self.header._comp_dict["zxy"][
-                "ch"
-            ].azimuth[0]
+            ch.translated_azimuth = self.header._comp_dict["zxy"]["ch"].azimuth[
+                0
+            ]
             ch.measurement_tilt = self.header._comp_dict["zxy"]["ch"].incl[0]
             ch.translated_tilt = self.header._comp_dict["zxy"]["ch"].incl[0]
             ch.channel_id = self.header._comp_dict["zxy"]["ch"].number[0]
@@ -347,9 +343,9 @@ class ZongeMTAvg:
             ch.measurement_azimuth = self.header._comp_dict["zyx"][
                 "ch"
             ].azimuth[0]
-            ch.translated_azimuth = self.header._comp_dict["zyx"][
-                "ch"
-            ].azimuth[0]
+            ch.translated_azimuth = self.header._comp_dict["zyx"]["ch"].azimuth[
+                0
+            ]
             ch.measurement_tilt = self.header._comp_dict["zyx"]["ch"].incl[0]
             ch.translated_tilt = self.header._comp_dict["zyx"]["ch"].incl[0]
             ch.channel_id = self.header._comp_dict["zyx"]["ch"].number[0]
@@ -370,9 +366,9 @@ class ZongeMTAvg:
             ch.measurement_azimuth = self.header._comp_dict["zyx"][
                 "ch"
             ].azimuth[1]
-            ch.translated_azimuth = self.header._comp_dict["zyx"][
-                "ch"
-            ].azimuth[1]
+            ch.translated_azimuth = self.header._comp_dict["zyx"]["ch"].azimuth[
+                1
+            ]
             ch.measurement_tilt = self.header._comp_dict["zyx"]["ch"].incl[1]
             ch.translated_tilt = self.header._comp_dict["zyx"]["ch"].incl[1]
             ch.sensor.id = self.header._comp_dict["zyx"]["ch"].number[1]
@@ -394,9 +390,9 @@ class ZongeMTAvg:
             ch.measurement_azimuth = self.header._comp_dict["zxy"][
                 "ch"
             ].azimuth[1]
-            ch.translated_azimuth = self.header._comp_dict["zxy"][
-                "ch"
-            ].azimuth[1]
+            ch.translated_azimuth = self.header._comp_dict["zxy"]["ch"].azimuth[
+                1
+            ]
             ch.measurement_tilt = self.header._comp_dict["zxy"]["ch"].incl[1]
             ch.translated_tilt = self.header._comp_dict["zxy"]["ch"].incl[1]
             ch.sensor.id = self.header._comp_dict["zxy"]["ch"].number[1]
@@ -418,9 +414,9 @@ class ZongeMTAvg:
             ch.measurement_azimuth = self.header._comp_dict["tzx"][
                 "ch"
             ].azimuth[1]
-            ch.translated_azimuth = self.header._comp_dict["tzx"][
-                "ch"
-            ].azimuth[1]
+            ch.translated_azimuth = self.header._comp_dict["tzx"]["ch"].azimuth[
+                1
+            ]
             ch.measurement_tilt = self.header._comp_dict["tzx"]["ch"].incl[1]
             ch.translated_tilt = self.header._comp_dict["tzx"]["ch"].incl[1]
             ch.sensor.id = self.header._comp_dict["tzx"]["ch"].number[1]

mt_metadata/transfer_functions/processing/__init__.py

@@ -1 +1,2 @@
-
+from .time_series_decimation import TimeSeriesDecimation
+from .window import Window

mt_metadata/transfer_functions/processing/aurora/__init__.py

@@ -1,25 +1,23 @@
 from .band import Band
 from .channel import Channel
 from .channel_nomenclature import ChannelNomenclature
-from .window import Window
-from .decimation import Decimation
 from .decimation_level import DecimationLevel
 from .estimator import Estimator
+from .frequency_bands import FrequencyBands
 from .processing import Processing
 from .regression import Regression
 from .run import Run
 from .station import Station
 from .stations import Stations
 
-
 __all__ = [
     "Band",
     "Channel",
     "ChannelNomenclature",
-    "Window",
     "Decimation",
     "DecimationLevel",
     "Estimator",
+    "FrequencyBands",
     "Processing",
     "Regression",
     "Run",

mt_metadata/transfer_functions/processing/aurora/band.py

@@ -3,6 +3,10 @@
 Created on Fri Feb 25 15:20:59 2022
 
 @author: jpeacock
+
+Development Notes:
+    To add better overlap and intersection checking, consider using piso
+    https://piso.readthedocs.io/en/latest/getting_started/index.html
 """
 # =============================================================================
 # Imports
@@ -12,6 +16,7 @@ import pandas as pd
 from mt_metadata.base.helpers import write_lines
 from mt_metadata.base import get_schema, Base
 from .standards import SCHEMA_FN_PATHS
+from typing import Optional
 
 # =============================================================================
 attr_dict = get_schema("band", SCHEMA_FN_PATHS)
@@ -22,28 +27,38 @@ class Band(Base):
     __doc__ = write_lines(attr_dict)
 
     def __init__(self, **kwargs):
+        """
+            Constructor.
+
+            :param kwargs: TODO description here
+        """
 
         super().__init__(attr_dict=attr_dict, **kwargs)
         self._name = None
 
     @property
-    def lower_bound(self):
+    def lower_bound(self) -> float:
         return self.frequency_min
 
     @property
-    def upper_bound(self):
+    def upper_bound(self) -> float:
         return self.frequency_max
 
     @property
-    def lower_closed(self):
+    def width(self) -> float:
+        """ returns the width of the band (the bandwidth)."""
+        return self.upper_bound - self.lower_bound
+
+    @property
+    def lower_closed(self) -> bool:
         return self.to_interval().closed_left
 
     @property
-    def upper_closed(self):
+    def upper_closed(self) -> bool:
         return self.to_interval().closed_right
 
     @property
-    def name(self):
+    def name(self) -> str:
         """
         :return: The name of the frequency band (currently defaults to fstring with 6 decimal places.
         :rtype: str
@@ -57,7 +72,7 @@ class Band(Base):
     def name(self, value):
         self._name = value
 
-    def _indices_from_frequencies(self, frequencies):
+    def _indices_from_frequencies(self, frequencies: np.ndarray) -> np.ndarray:
         """
 
         Parameters
@@ -84,7 +99,7 @@ class Band(Base):
         indices = np.where(cond1 & cond2)[0]
         return indices
 
-    def set_indices_from_frequencies(self, frequencies):
+    def set_indices_from_frequencies(self, frequencies: np.ndarray) -> None:
         """assumes min/max freqs are defined"""
         indices = self._indices_from_frequencies(frequencies)
         self.index_min = indices[0]
@@ -98,7 +113,7 @@ class Band(Base):
     @property
     def harmonic_indices(self):
         """
-        Assumes all harmincs between min and max are present in the band
+        Assumes all harmoincs between min and max are present in the band
 
         Returns
         -------
@@ -106,7 +121,7 @@ class Band(Base):
         """
         return np.arange(self.index_min, self.index_max + 1)
 
-    def in_band_harmonics(self, frequencies):
+    def in_band_harmonics(self, frequencies: np.ndarray):
         """
         Parameters
         ----------
@@ -122,7 +137,7 @@ class Band(Base):
         return harmonics
 
     @property
-    def center_frequency(self):
+    def center_frequency(self) -> float:
         """
         Returns
         -------
@@ -135,131 +150,37 @@ class Band(Base):
             return (self.lower_bound + self.upper_bound) / 2
 
     @property
-    def center_period(self):
+    def center_period(self) -> float:
+        """ Returns the inverse of center frequency."""
         return 1.0 / self.center_frequency
 
+    def overlaps(self, other) -> bool:
+        """ Check if this band overlaps with another"""
+        ivl = self.to_interval()
+        other_ivl = other.to_interval()
+        return ivl.overlaps(other_ivl)
 
-class FrequencyBands(object):
-    """
-    This is just collection of objects of class Band.
-    It is intended to be used at a single decimation level
-
-    The core underlying variable is "band_edges", a 2D array, with one row per
-    frequency band and two columns, one for the left-hand (lower bound) of the
-    frequency band and one for the right-hand (upper bound).
-
-    Note there are some "clever" ways to define the bands using a 1-D array but this
-    assumes the bands to be adjacent, and there is no good reason to bake this
-    constriant in -- band edges is thus 2-D.
-    """
-
-    def __init__(self, **kwargs):
-        """
-
-        Parameters
-        ----------
-        kwargs
-        band_edges: 2d numpy array
-        """
-        self.band_edges = kwargs.get("band_edges", None)
+    def contains(self, other) -> bool:
+        """ Check if this band contains nother """
+        ivl = self.to_interval()
+        cond1 = ivl.__contains__(other.lower_bound)
+        cond2 = ivl.__contains__(other.upper_bound)
+        return cond1 & cond2
 
     @property
-    def number_of_bands(self):
-        return self.band_edges.shape[0]
-
-    def validate(self):
+    def fractional_bandwidth(self):
         """
-        Placeholder for sanity checks.
-        Main reason for this is in anticipation of an append() method that accepts Band objects.
-        In that case we may wish to re-order the band edges.
+            See
+            - https://en.wikipedia.org/wiki/Bandwidth_(signal_processing)#Fractional_bandwidth
+            - https://en.wikipedia.org/wiki/Q_factor
 
-        """
-        band_centers = self.band_centers()
-
-        # check band centers are monotonically increasing
-        monotone_condition = np.all(band_centers[1:] > band_centers[:-1])
-        if monotone_condition:
-            pass
-        else:
-            print(
-                "WARNING Band Centers are Not Monotonic.  This probably means that "
-                "the bands are being defined in an adhoc way"
-            )
-            print("This condition untested 20210720")
-            print("Attempting to reorganize bands")
-            # use np.argsort to rorganize the bands
-            self.band_edges = self.band_edges[np.argsort(band_centers), :]
-
-        return
-
-    def bands(self, direction="increasing_frequency"):
-        """
-        make this a generator for iteration over bands
         Returns
         -------
 
         """
-        band_indices = range(self.number_of_bands)
-        if direction == "increasing_period":
-            band_indices = np.flip(band_indices)
-        return (self.band(i_band) for i_band in band_indices)
+        return self.width / self.center_frequency
 
-    def band(self, i_band):
-        """
-        Parameters
-        ----------
-        i_band: integer (zero-indexed)
-            Specifies the band to return
-
-        Returns
-        -------
-        frequency_band: Band()
-            Class that represents a frequency band
-        """
-
-        frequency_band = Band(
-            frequency_min=self.band_edges[i_band, 0],
-            frequency_max=self.band_edges[i_band, 1],
-        )
-        return frequency_band
-
-    def band_centers(self, frequency_or_period="frequency"):
-        """
-        Parameters
-        ----------
-        frequency_or_period : str
-            One of ["frequency" , "period"].  Determines if the vector of band
-            centers is returned in "Hz" or "s"
-
-        Returns
-        -------
-        band_centers : numpy array
-            center frequencies of the bands in Hz or in s
-        """
-        band_centers = np.full(self.number_of_bands, np.nan)
-        for i_band in range(self.number_of_bands):
-            frequency_band = self.band(i_band)
-            band_centers[i_band] = frequency_band.center_frequency
-        if frequency_or_period == "period":
-            band_centers = 1.0 / band_centers
-        return band_centers
-
-    def from_decimation_object(self, decimation_object):
-        """
-        Define band_edges array from config object,
+    @property
+    def Q(self):
+        return 1./self.fractional_bandwidth
 
-        Parameters
-        ----------
-        decimation_object: mt_metadata.transfer_functions.processing.aurora.Decimation
-        """
-        # replace below with decimation_object.delta_frequency ?
-        df = (
-            decimation_object.decimation.sample_rate
-            / decimation_object.window.num_samples
-        )
-        half_df = df / 2.0
-        # half_df /=100
-        lower_edges = (decimation_object.lower_bounds * df) - half_df
-        upper_edges = (decimation_object.upper_bounds * df) + half_df
-        band_edges = np.vstack((lower_edges, upper_edges)).T
-        self.band_edges = band_edges

mt_metadata/transfer_functions/processing/aurora/channel_nomenclature.py

@@ -8,15 +8,27 @@
 # =============================================================================
 from mt_metadata.base.helpers import write_lines
 from mt_metadata.base import get_schema, Base
-from .standards import SCHEMA_FN_PATHS
-
 from mt_metadata.transfer_functions import CHANNEL_MAPS
+from .standards import SCHEMA_FN_PATHS
 
+from typing import Dict, Literal
 # =============================================================================
 attr_dict = get_schema("channel_nomenclature", SCHEMA_FN_PATHS)
 
+# ====================== Nomenclature definitions for typehints and docstrings ============= #
+
+SupportedNomenclature = Literal[
+    "default",
+    "lemi12",
+    "lemi34",
+    "musgraves",
+    "nims",
+    "phoenix123",
+]
+
 
 # =============================================================================
+
 class ChannelNomenclature(Base):
     __doc__ = write_lines(attr_dict)
 
@@ -64,25 +76,20 @@ class ChannelNomenclature(Base):
         self._keyword = keyword
         self.update()
 
-    def get_channel_map(self):
-        if self.keyword == "default":
-            channel_map = CHANNEL_MAPS["default"]
-        elif self.keyword.upper() == "LEMI12":
-            channel_map = CHANNEL_MAPS["lemi12"]
-        elif self.keyword.upper() == "LEMI34":
-            channel_map = CHANNEL_MAPS["lemi34"]
-        elif self.keyword.upper() == "NIMS":
-            channel_map = CHANNEL_MAPS["default"]
-        elif self.keyword.upper() == "PHOENIX123":
-            channel_map = CHANNEL_MAPS["phoenix123"]
-        elif self.keyword.upper() == "MUSGRAVES":
-            channel_map = CHANNEL_MAPS["musgraves"]
-        else:
-            msg = f"channel mt_system {self.keyword} unknown"
+    def get_channel_map(self) -> Dict[str,str]:
+        """
+            Based on self.keyword return the mapping between conventional channel names and
+            the custom channel names in the particular nomenclature.
+
+        """
+        try:
+            return CHANNEL_MAPS[self.keyword.lower()]
+        except KeyError:
+            msg = f"channel mt_system {self.keyword} unknown)"
             raise NotImplementedError(msg)
-        return channel_map
 
-    def update(self):
+
+    def update(self) -> None:
         """
         Assign values to standard channel names "ex", "ey" etc based on channel_map dict
         """
@@ -93,7 +100,7 @@ class ChannelNomenclature(Base):
         self.hy = channel_map["hy"]
         self.hz = channel_map["hz"]
 
-    def unpack(self):
+    def unpack(self) -> tuple:
         return self.ex, self.ey, self.hx, self.hy, self.hz
 
     @property