Updates

mtpy/core/mt_data.py

@@ -421,6 +421,38 @@
         except KeyError:
             raise KeyError(f"Could not find {station_key} in MTData.")
 
+    def apply_bounding_box(self, lon_min, lon_max, lat_min, lat_max):
+        """
+        Apply a bounding box
+
+
+        :param lon_min: DESCRIPTION
+        :type lon_min: TYPE
+        :param lon_max: DESCRIPTION
+        :type lon_max: TYPE
+        :param lat_min: DESCRIPTION
+        :type lat_min: TYPE
+        :param lat_max: DESCRIPTION
+        :type lat_max: TYPE
+        :return: DESCRIPTION
+        :rtype: TYPE
+
+        """
+
+        bb_df = self.station_locations.loc[
+            (self.station_locations.longitude >= lon_min)
+            & (self.station_locations.longitude <= lon_max)
+            & (self.station_locations.latitude >= lat_min)
+            & (self.station_locations.latitude <= lat_max)
+        ]
+
+        station_keys = [
+            f"{survey}.{station}"
+            for survey, station in zip(bb_df.survey, bb_df.station)
+        ]
+
+        return self.get_subset(station_keys)
+
     def get_subset(self, station_list):
         """
         get a subset of the data from a list of stations, could be station_id
@@ -1199,6 +1231,22 @@
 
         return PlotPhaseTensorMaps(mt_data=self, **kwargs)
 
+    def plot_tipper_map(self, **kwargs):
+        """
+        Plot Phase tensor maps for transfer functions in the working_dataframe
+
+        .. seealso:: :class:`mtpy.imaging.PlotPhaseTensorMaps`
+
+        :param **kwargs: DESCRIPTION
+        :type **kwargs: TYPE
+        :return: DESCRIPTION
+        :rtype: TYPE
+
+        """
+        kwargs["plot_pt"] = False
+        kwargs["plot_tipper"] = "yri"
+        return PlotPhaseTensorMaps(mt_data=self, **kwargs)
+
     def plot_phase_tensor_pseudosection(self, mt_data=None, **kwargs):
         """
         Plot a pseudo section of  phase tensor ellipses and induction vectors
@@ -1306,7 +1354,7 @@
 
         return PlotResidualPTMaps(survey_data_01, survey_data_02, **kwargs)
 
-    def to_shp(
+    def to_shp_pt_tipper(
         self,
         save_dir,
         output_crs=None,

mtpy/imaging/mtplot_tools/arrows.py

@@ -5,6 +5,7 @@
 @author: jpeacock
 """
 
+
 # ==============================================================================
 # Arrows properties for induction vectors
 # ==============================================================================
@@ -36,8 +37,8 @@ class MTArrows:
                   scaling by 'size'
 
     * 'direction : [ 0 | 1 ]
-                 - 0 for arrows to point toward a conductor
-                 - 1 for arrow to point away from conductor
+                 - 0 for arrows to point away a conductor
+                 - 1 for arrow to point toward from conductor
 
     """
 
@@ -51,7 +52,9 @@ def __init__(self, **kwargs):
         self.arrow_threshold = 2
         self.arrow_color_imag = "c"
         self.arrow_color_real = "k"
-        self.arrow_direction = 0
+        # the data is inherently pointing away from conductor, need to flip
+        # to be in parkinson convention
+        self.arrow_direction = 1
 
         # Set class property values from kwargs and pop them
         for v in vars(self):

mtpy/imaging/mtplot_tools/base.py

@@ -336,32 +336,30 @@
             np.array(
                 [
                     [
-                        tf.z_interp_dict["zxx"]["real"](1 / self.plot_period)[
-                            0
-                        ]
+                        tf.z_interp_dict["zxx"]["real"](1 / self.plot_period)[0]
                         + 1j
                         * tf.z_interp_dict["zxx"]["imag"](
                             1.0 / self.plot_period
                         )[0],
-                        tf.z_interp_dict["zxy"]["real"](
-                            1.0 / self.plot_period
-                        )[0]
+                        tf.z_interp_dict["zxy"]["real"](1.0 / self.plot_period)[
+                            0
+                        ]
                         + 1j
                         * tf.z_interp_dict["zxy"]["imag"](
                             1.0 / self.plot_period
                         )[0],
                     ],
                     [
-                        tf.z_interp_dict["zyx"]["real"](
-                            1.0 / self.plot_period
-                        )[0]
+                        tf.z_interp_dict["zyx"]["real"](1.0 / self.plot_period)[
+                            0
+                        ]
                         + 1j
                         * tf.z_interp_dict["zyx"]["imag"](
                             1.0 / self.plot_period
                         )[0],
-                        tf.z_interp_dict["zyy"]["real"](
-                            1.0 / self.plot_period
-                        )[0]
+                        tf.z_interp_dict["zyy"]["real"](1.0 / self.plot_period)[
+                            0
+                        ]
                         + 1j
                         * tf.z_interp_dict["zyy"]["imag"](
                             1.0 / self.plot_period
@@ -568,7 +566,7 @@
 
         """
 
-        return add_raster(ax, raster_fn, add_colorbar=True, **kwargs)
+        return add_raster(ax, raster_fn, add_colorbar=add_colorbar, **kwargs)
 
 
 class PlotBaseProfile(PlotBase):

mtpy/imaging/mtplot_tools/plot_settings.py

@@ -162,6 +162,40 @@
             10 ** (np.ceil(np.log10(period.max()))),
         )
 
+    def _estimate_resistivity_min(self, res_array):
+        """
+        estimate resistivity minimum
+        """
+
+        nz = np.nonzero(res_array)
+        return np.nanmin(res_array[nz])
+
+    def _estimate_resistivity_max(self, res_array):
+        """
+        estimate resistivity maximum
+        """
+
+        nz = np.nonzero(res_array)
+        return np.nanmax(res_array[nz])
+
+    def _compute_power_ten_min(self, value):
+        return 10 ** (np.floor(np.log10(value)))
+
+    def _compute_power_ten_max(self, value):
+        return 10 ** (np.ceil(np.log10(value)))
+
+    def _estimate_resistivity_limits_min(self, res_list):
+
+        return self._compute_power_ten_min(
+            min([self._estimate_resistivity_min(rr) for rr in res_list])
+        )
+
+    def _estimate_resistivity_limits_max(self, res_list):
+
+        return self._compute_power_ten_max(
+            max([self._estimate_resistivity_max(rr) for rr in res_list])
+        )
+
     def set_resistivity_limits(self, resistivity, mode="od", scale="log"):
         """
         set resistivity limits
@@ -176,82 +210,26 @@
         """
 
         if mode in ["od"]:
-            try:
-                nz_xy = np.nonzero(resistivity[:, 0, 1])
-                nz_yx = np.nonzero(resistivity[:, 1, 0])
-                limits = [
-                    10
-                    ** (
-                        np.floor(
-                            np.log10(
-                                min(
-                                    [
-                                        np.nanmin(resistivity[nz_xy, 0, 1]),
-                                        np.nanmin(resistivity[nz_yx, 1, 0]),
-                                    ]
-                                )
-                            )
-                        )
-                    ),
-                    10
-                    ** (
-                        np.ceil(
-                            np.log10(
-                                max(
-                                    [
-                                        np.nanmax(resistivity[nz_xy, 0, 1]),
-                                        np.nanmax(resistivity[nz_yx, 1, 0]),
-                                    ]
-                                )
-                            )
-                        )
-                    ),
-                ]
-            except (ValueError, TypeError):
-                limits = [0.1, 10000]
+            res_list = [resistivity[:, 0, 1], resistivity[:, 1, 0]]
+
         elif mode == "d":
-            try:
-                nz_xx = np.nonzero(resistivity[:, 0, 1])
-                nz_yy = np.nonzero(resistivity[:, 1, 0])
-                limits = [
-                    10
-                    ** (
-                        np.floor(
-                            np.log10(
-                                min(
-                                    [
-                                        np.nanmin(resistivity[nz_xx, 0, 0]),
-                                        np.nanmin(resistivity[nz_yy, 1, 1]),
-                                    ]
-                                )
-                            )
-                        )
-                    ),
-                    10
-                    ** (
-                        np.ceil(
-                            np.log10(
-                                max(
-                                    [
-                                        np.nanmax(resistivity[nz_xx, 0, 0]),
-                                        np.nanmax(resistivity[nz_yy, 1, 1]),
-                                    ]
-                                )
-                            )
-                        )
-                    ),
-                ]
-            except (ValueError, TypeError):
-                limits = [0.1, 10000]
+            res_list = [resistivity[:, 0, 0], resistivity[:, 1, 1]]
         elif mode in ["det", "det_only"]:
-            try:
-                nz = np.nonzero(resistivity)
-                limits = [
-                    10 ** (np.floor(np.log10(np.nanmin(resistivity[nz])))),
-                    10 ** (np.ceil(np.log10(np.nanmax(resistivity[nz])))),
-                ]
-            except (ValueError, TypeError):
-                limits = [0.1, 10000]
+            res_list = [resistivity]
+        elif mode in ["all"]:
+            res_list = [
+                resistivity[:, 0, 0],
+                resistivity[:, 0, 1],
+                resistivity[:, 1, 0],
+                resistivity[:, 1, 1],
+            ]
+        try:
+            limits = [
+                self._estimate_resistivity_limits_min(res_list),
+                self._estimate_resistivity_limits_max(res_list),
+            ]
+        except (ValueError, TypeError):
+            limits = [0.1, 10000]
         if scale == "log":
             if limits[0] == 0:
                 limits[0] = 0.1

mtpy/imaging/mtplot_tools/plotters.py

@@ -339,6 +339,7 @@ def plot_tipper_lateral(
     font_size=6,
     legend=True,
     zero_reference=False,
+    arrow_direction=1,
 ):
     """
 
@@ -357,11 +358,19 @@ def plot_tipper_lateral(
         return None, None, None
 
     if plot_tipper.find("y") == 0 or plot_tipper:
-        txr = t_obj.mag_real * np.cos(np.deg2rad(-t_obj.angle_real))
-        tyr = t_obj.mag_real * np.sin(np.deg2rad(-t_obj.angle_real))
+        txr = t_obj.mag_real * np.cos(
+            np.deg2rad(-t_obj.angle_real) + arrow_direction * np.pi
+        )
+        tyr = t_obj.mag_real * np.sin(
+            np.deg2rad(-t_obj.angle_real) + arrow_direction * np.pi
+        )
 
-        txi = t_obj.mag_imag * np.cos(np.deg2rad(-t_obj.angle_imag))
-        tyi = t_obj.mag_imag * np.sin(np.deg2rad(-t_obj.angle_imag))
+        txi = t_obj.mag_imag * np.cos(
+            np.deg2rad(-t_obj.angle_imag) + arrow_direction * np.pi
+        )
+        tyi = t_obj.mag_imag * np.sin(
+            np.deg2rad(-t_obj.angle_imag) + arrow_direction * np.pi
+        )
 
         nt = len(txr)
         period = 1.0 / t_obj.frequency

mtpy/imaging/plot_mt_response.py

@@ -252,8 +252,8 @@
                 2,
                 subplot_spec=gs_master[0],
                 height_ratios=[2, 1.5],
-                hspace=0.05,
-                wspace=0.15,
+                hspace=self.subplot_hspace,
+                wspace=self.subplot_wspace,
             )
 
             # --> make figure for xy,yx components
@@ -482,6 +482,7 @@
                 self.arrow_real_properties,
                 self.arrow_imag_properties,
                 self.font_size,
+                arrow_direction=self.arrow_direction,
             )
             if self.plot_tipper.find("y") >= 0:
                 self.axt.set_xlabel("Period (s)", fontdict=self.font_dict)
@@ -579,9 +580,14 @@
 
         if self.plot_z:
             if self.res_limits is None:
-                self.res_limits = self.set_resistivity_limits(
-                    self.Z.resistivity
-                )
+                if self.plot_num == 1:
+                    self.res_limits = self.set_resistivity_limits(
+                        self.Z.resistivity
+                    )
+                elif self.plot_num == 2 or self.plot_num == 3:
+                    self.res_limits = self.set_resistivity_limits(
+                        self.Z.resistivity, mode="all"
+                    )
 
             eb_list, labels = self._plot_resistivity(
                 self.axr, self.period, self.Z, mode="od"
@@ -594,9 +600,11 @@
             if self.plot_num == 2:
                 self._plot_resistivity(self.axr2, self.period, self.Z, mode="d")
                 self._plot_phase(self.axp2, self.period, self.Z, mode="d")
+
             # ===Plot the Determinant if desired================================
             if self.plot_num == 3:
                 self._plot_determinant()
+
         self._plot_tipper()
         self._plot_pt()