updated grid handling (add 'empty')

murrayrm · murrayrm · commit 8776875cda88 · 2023-12-28T12:42:52.000-08:00
diff --git a/control/freqplot.py b/control/freqplot.py
@@ -162,7 +162,7 @@ def bode_plot(
         values with no plot.
     rcParams : dict
         Override the default parameters used for generating plots.
-        Default is set up config.default['freqplot.rcParams'].
+        Default is set by config.default['freqplot.rcParams'].
     wrap_phase : bool or float
         If wrap_phase is `False` (default), then the phase will be unwrapped
         so that it is continuously increasing or decreasing.  If wrap_phase is
diff --git a/control/matlab/wrappers.py b/control/matlab/wrappers.py
@@ -195,6 +195,7 @@ def _parse_freqplot_args(*args):
     return syslist, omega, plotstyle, other
 
 
+# TODO: rewrite to call root_locus_map, without using legacy plot keyword
 def rlocus(*args, **kwargs):
     """rlocus(sys[, klist, xlim, ylim, ...])
 
@@ -248,6 +249,7 @@ def rlocus(*args, **kwargs):
     return retval
 
 
+# TODO: rewrite to call pole_zero_map, without using legacy plot keyword
 def pzmap(*args, **kwargs):
     """pzmap(sys[, grid, plot])
 
diff --git a/control/pzmap.py b/control/pzmap.py
@@ -125,13 +125,14 @@ def pole_zero_plot(
     Parameters
     ----------
     sysdata : List of PoleZeroData objects or LTI systems
-        List of pole/zero response data objects generated by pzmap_response
+        List of pole/zero response data objects generated by pzmap_response()
         or rootlocus_response() that are to be plotted.  If a list of systems
         is given, the poles and zeros of those systems will be plotted.
-    grid : boolean (default = None)
-        If True plot omega-damping grid, otherwise show imaginary axis for
-        continuous time systems, unit circle for discrete time systems.  If
-        `False`, do not draw any additonal lines.
+    grid : bool or str, optional
+        If `True` plot omega-damping grid, if `False` show imaginary axis
+        for continuous time systems, unit circle for discrete time systems.
+        If `empty`, do not draw any additonal lines.  Default value is set
+        by config.default['pzmap.grid'] or config.default['rlocus.grid'].
     plot : bool, optional
         (legacy) If ``True`` a graph is generated with Matplotlib,
         otherwise the poles and zeros are only computed and returned.
@@ -188,7 +189,7 @@ def pole_zero_plot(
 
     """
     # Get parameter values
-    grid = config._get_param('pzmap', 'grid', grid, None)
+    grid = config._get_param('pzmap', 'grid', grid, _pzmap_defaults)
     marker_size = config._get_param('pzmap', 'marker_size', marker_size, 6)
     marker_width = config._get_param('pzmap', 'marker_width', marker_width, 1.5)
     xlim_user, ylim_user = xlim, ylim
@@ -246,7 +247,7 @@ def pole_zero_plot(
         fig, axs = plt.figure(), []
 
     with plt.rc_context(freqplot_rcParams):
-        if grid:
+        if grid and grid != 'empty':
             plt.clf()
             if all([isctime(dt=response.dt) for response in data]):
                 ax, fig = sgrid(scaling=scaling)
@@ -256,16 +257,20 @@ def pole_zero_plot(
                 ValueError(
                     "incompatible time responses; don't know how to grid")
         elif len(axs) == 0:
-            if grid is False:
+            if grid == 'empty':
                 # Leave off grid entirely
                 ax = plt.axes()
             else:
-                # use first response timebase
+                # draw stability boundary; use first response timebase
                 ax, fig = nogrid(data[0].dt, scaling=scaling)
         else:
             # Use the existing axes and any grid that is there
             ax = axs[0]
 
+            # Issue a warning if the user tried to set the grid type
+            if grid:
+                warnings.warn("axis already exists; grid keyword ignored")
+
     # Handle color cycle manually as all root locus segments
     # of the same system are expected to be of the same color
     color_cycle = plt.rcParams['axes.prop_cycle'].by_key()['color']
diff --git a/control/rlocus.py b/control/rlocus.py
@@ -24,7 +24,6 @@
 from .iosys import isdtime
 from .xferfcn import _convert_to_transfer_function
 from .exception import ControlMIMONotImplemented
-from .grid import sgrid, zgrid
 from . import config
 import warnings
 
@@ -96,19 +95,25 @@ def root_locus_plot(
         (see :doc:`matplotlib:api/axes_api`).
     plotstr : :func:`matplotlib.pyplot.plot` format string, optional
         plotting style specification
+        TODO: check
     plot : boolean, optional
         If True (default), plot root locus diagram.
+        TODO: legacy
     print_gain : bool
         If True (default), report mouse clicks when close to the root locus
         branches, calculate gain, damping and print.
-    grid : bool
-        If True plot omega-damping grid.  Default is False.
+        TODO: update
+    grid : bool or str, optional
+        If `True` plot omega-damping grid, if `False` show imaginary axis
+        for continuous time systems, unit circle for discrete time systems.
+        If `empty`, do not draw any additonal lines.  Default value is set
+        by config.default['rlocus.grid'].
     ax : :class:`matplotlib.axes.Axes`
         Axes on which to create root locus plot
     initial_gain : float, optional
         Specify the initial gain to use when marking current gain. [TODO: update]
 
-    Returns
+    Returns (TODO: update)
     -------
     roots : ndarray
         Closed-loop root locations, arranged in which each row corresponds
@@ -156,8 +161,7 @@ def root_locus_plot(
     return out
 
 
-# TODO: get rid of zoom functionality?
-def _default_gains(num, den, xlim, ylim, zoom_xlim=None, zoom_ylim=None):
+def _default_gains(num, den, xlim, ylim):
     """Unsupervised gains calculation for root locus plot.
 
     References
@@ -237,8 +241,7 @@ def _default_gains(num, den, xlim, ylim, zoom_xlim=None, zoom_ylim=None):
         tolerance = x_tolerance
     else:
         tolerance = np.min([x_tolerance, y_tolerance])
-    indexes_too_far = _indexes_filt(
-        root_array, tolerance, zoom_xlim, zoom_ylim)
+    indexes_too_far = _indexes_filt(root_array, tolerance)
 
     # Add more points into the root locus for points that are too far apart
     while len(indexes_too_far) > 0 and kvect.size < 5000:
@@ -250,8 +253,7 @@ def _default_gains(num, den, xlim, ylim, zoom_xlim=None, zoom_ylim=None):
             root_array = np.insert(root_array, index + 1, new_points, axis=0)
 
         root_array = _RLSortRoots(root_array)
-        indexes_too_far = _indexes_filt(
-            root_array, tolerance, zoom_xlim, zoom_ylim)
+        indexes_too_far = _indexes_filt(root_array, tolerance)
 
     new_gains = kvect[-1] * np.hstack((np.logspace(0, 3, 4)))
     new_points = _RLFindRoots(num, den, new_gains[1:4])
@@ -261,7 +263,7 @@ def _default_gains(num, den, xlim, ylim, zoom_xlim=None, zoom_ylim=None):
     return kvect, root_array, xlim, ylim
 
 
-def _indexes_filt(root_array, tolerance, zoom_xlim=None, zoom_ylim=None):
+def _indexes_filt(root_array, tolerance):
     """Calculate the distance between points and return the indices.
 
     Filter the indexes so only the resolution of points within the xlim and
@@ -270,48 +272,6 @@ def _indexes_filt(root_array, tolerance, zoom_xlim=None, zoom_ylim=None):
     """
     distance_points = np.abs(np.diff(root_array, axis=0))
     indexes_too_far = list(np.unique(np.where(distance_points > tolerance)[0]))
-
-    if zoom_xlim is not None and zoom_ylim is not None:
-        x_tolerance_zoom = 0.05 * (zoom_xlim[1] - zoom_xlim[0])
-        y_tolerance_zoom = 0.05 * (zoom_ylim[1] - zoom_ylim[0])
-        tolerance_zoom = np.min([x_tolerance_zoom, y_tolerance_zoom])
-        indexes_too_far_zoom = list(
-            np.unique(np.where(distance_points > tolerance_zoom)[0]))
-        indexes_too_far_filtered = []
-
-        for index in indexes_too_far_zoom:
-            for point in root_array[index]:
-                if (zoom_xlim[0] <= point.real <= zoom_xlim[1]) and \
-                   (zoom_ylim[0] <= point.imag <= zoom_ylim[1]):
-                    indexes_too_far_filtered.append(index)
-                    break
-
-        # Check if zoom box is not overshot & insert points where neccessary
-        if len(indexes_too_far_filtered) == 0 and len(root_array) < 500:
-            limits = [zoom_xlim[0], zoom_xlim[1], zoom_ylim[0], zoom_ylim[1]]
-            for index, limit in enumerate(limits):
-                if index <= 1:
-                    asign = np.sign(real(root_array)-limit)
-                else:
-                    asign = np.sign(imag(root_array) - limit)
-                signchange = ((np.roll(asign, 1, axis=0)
-                               - asign) != 0).astype(int)
-                signchange[0] = np.zeros((len(root_array[0])))
-                if len(np.where(signchange == 1)[0]) > 0:
-                    indexes_too_far_filtered.append(
-                        np.where(signchange == 1)[0][0]-1)
-
-        if len(indexes_too_far_filtered) > 0:
-            if indexes_too_far_filtered[0] != 0:
-                indexes_too_far_filtered.insert(
-                    0, indexes_too_far_filtered[0]-1)
-            if not indexes_too_far_filtered[-1] + 1 >= len(root_array) - 2:
-                indexes_too_far_filtered.append(
-                    indexes_too_far_filtered[-1] + 1)
-
-        indexes_too_far.extend(indexes_too_far_filtered)
-
-    indexes_too_far = list(np.unique(indexes_too_far))
     indexes_too_far.sort()
     return indexes_too_far
 
diff --git a/control/tests/rlocus_test.py b/control/tests/rlocus_test.py
@@ -66,20 +66,38 @@ def test_without_gains(self, sys):
         roots, kvect = root_locus(sys, plot=False)
         self.check_cl_poles(sys, roots, kvect)
 
-    @pytest.mark.skip("TODO: update test for rlocus gridlines")
-    @pytest.mark.slow
-    @pytest.mark.parametrize('grid', [None, True, False])
+    @pytest.mark.parametrize("grid", [None, True, False, 'empty'])
     def test_root_locus_plot_grid(self, sys, grid):
-        rlist, klist = root_locus(sys, plot=True, grid=grid)
+        import mpl_toolkits.axisartist as AA
+
+        # Generate the root locus plot
+        plt.clf()
+        ct.root_locus_plot(sys, grid=grid)
+
+        # Count the number of dotted/dashed lines in the plot
         ax = plt.gca()
-        n_gridlines = sum([int(line.get_linestyle() in [':', 'dotted',
-                                                        '--', 'dashed'])
-                           for line in ax.lines])
-        if grid is False:
-            assert n_gridlines == 2
-        else:
+        n_gridlines = sum([int(
+            line.get_linestyle() in [':', 'dotted', '--', 'dashed'] or
+            line.get_linewidth() < 1
+        ) for line in ax.lines])
+
+        # Make sure they line up with what we expect
+        if grid == 'empty':
+            assert n_gridlines == 0
+            assert not isinstance(ax, AA.Axes)
+        elif grid is False:
+            assert n_gridlines == 2 if sys.isctime() else 3
+            assert not isinstance(ax, AA.Axes)
+        elif sys.isdtime(strict=True):
             assert n_gridlines > 2
-        # TODO check validity of grid
+            assert not isinstance(ax, AA.Axes)
+        else:
+            # Continuous time, with grid => check that AxisArtist was used
+            assert isinstance(ax, AA.Axes)
+            for spine in ['wnxneg', 'wnxpos', 'wnyneg', 'wnypos']:
+                assert spine in ax.axis
+
+        # TODO: check validity of grid
 
     @pytest.mark.filterwarnings("ignore:.*return values.*:DeprecationWarning")
     def test_root_locus_neg_false_gain_nonproper(self):
@@ -89,7 +107,7 @@ def test_root_locus_neg_false_gain_nonproper(self):
 
     # TODO: cover and validate negative false_gain branch in _default_gains()
 
-    @pytest.mark.skip("TODO: update test to check click dispatcher")
+    @pytest.mark.skip("Zooming functionality no longer implemented")
     @pytest.mark.skipif(plt.get_current_fig_manager().toolbar is None,
                         reason="Requires the zoom toolbar")
     def test_root_locus_zoom(self):
