addressed @slivingston review comments

murrayrm · murrayrm · commit bb52b70a6dc8 · 2024-12-06T20:57:29.000-08:00
diff --git a/control/statefbk.py b/control/statefbk.py
@@ -696,11 +696,11 @@ def create_statefbk_iosystem(
     -------
     ctrl : NonlinearIOSystem
         Input/output system representing the controller.  For the 'trajgen'
-        design patter (default), this system takes as inputs the desired
+        design pattern (default), this system takes as inputs the desired
         state `x_d`, the desired input `u_d`, and either the system state
         `x` or the estimated state `xhat`.  It outputs the controller
         action `u` according to the formula `u = u_d - K(x - x_d)`.  For
-        the 'refgain' design patter, the system takes as inputs the
+        the 'refgain' design pattern, the system takes as inputs the
         reference input `r` and the system or estimated state. If the
         keyword `integral_action` is specified, then an additional set of
         integrators is included in the control system (with the gain matrix
@@ -779,6 +779,11 @@ def create_statefbk_iosystem(
     if kwargs:
         raise TypeError("unrecognized keywords: ", str(kwargs))
 
+    # Check for consistency of positional parameters
+    if feedfwd_gain is not None and feedfwd_pattern != 'refgain':
+        raise ControlArgument(
+            "feedfwd_gain specified but feedfwd_pattern != 'refgain'")
+
     # Figure out what inputs to the system to use
     control_indices = _process_indices(
         control_indices, 'control', sys.input_labels, sys.ninputs)
diff --git a/control/tests/statefbk_test.py b/control/tests/statefbk_test.py
@@ -1145,8 +1145,10 @@ def test_gainsched_errors(unicycle):
 
 
 @pytest.mark.parametrize("ninputs, Kf", [
-    (1, 1), (1, None),
-    (2, np.diag([1, 1])), (2, None),
+    (1, 1),
+    (1, None),
+    (2, np.diag([1, 1])),
+    (2, None),
 ])
 def test_refgain_pattern(ninputs, Kf):
     sys = ct.rss(2, 2, ninputs, strictly_proper=True)
@@ -1178,3 +1180,17 @@ def test_refgain_pattern(ninputs, Kf):
     np.testing.assert_almost_equal(clsys.B, manual.B)
     np.testing.assert_almost_equal(clsys.C[:sys.nstates, :], manual.C)
     np.testing.assert_almost_equal(clsys.D[:sys.nstates, :], manual.D)
+
+
+def test_create_statefbk_errors():
+    sys = ct.rss(2, 2, 1, strictly_proper=True)
+    sys.C = np.eye(2)
+    K = -np.ones((1, 4))
+    Kf = 1
+
+    K, _, _ = ct.lqr(sys.A, sys.B, np.eye(sys.nstates), np.eye(sys.ninputs))
+    with pytest.raises(NotImplementedError, match="unknown pattern"):
+        ct.create_statefbk_iosystem(sys, K, feedfwd_pattern='mypattern')
+
+    with pytest.raises(ControlArgument, match="feedfwd_pattern != 'refgain'"):
+        ct.create_statefbk_iosystem(sys, K, Kf, feedfwd_pattern='trajgen')
diff --git a/doc/iosys.rst b/doc/iosys.rst
@@ -57,7 +57,7 @@ Example
 
 To illustrate the use of the input/output systems module, we create a
 model for a predator/prey system, following the notation and parameter
-values in FBS2e.
+values in `Feedback Systems <http://fbsbook.org>`_.
 
 We begin by defining the dynamics of the system
 
@@ -129,7 +129,8 @@ system and computing the linearization about that point.
 
 We next compute a controller that stabilizes the equilibrium point using
 eigenvalue placement and computing the feedforward gain using the number of
-lynxes as the desired output (following FBS2e, Example 7.5):
+lynxes as the desired output (following `Feedback Systems
+<http://fbsbook.org>`_, Example 7.5):
 
 .. code-block:: python
 
@@ -488,10 +489,10 @@ A reference gain controller can be created with the command::
 
   ctrl, clsys = ct.create_statefbk_iosystem(sys, K, kf, feedfwd_pattern='refgain')
 
-This reference gain design pattern is described in more detail in Section
-7.2 of FBS2e (Stabilization by State Feedback) and the trajectory
-generation design pattern is described in Section 8.5 (State Space
-Controller Design).
+This reference gain design pattern is described in more detail in
+Section 7.2 of `Feedback Systems <http://fbsbook.org>`_ (Stabilization
+by State Feedback) and the trajectory generation design pattern is
+described in Section 8.5 (State Space Controller Design).
 
 If the full system state is not available, the output of a state
 estimator can be used to construct the controller using the command::
