improve error messages for inconsistent size info in nlsys + small bug fix

murrayrm · murrayrm · commit 36263d8f8d95 · 2024-06-29T19:21:40.000-07:00
diff --git a/control/nlsys.py b/control/nlsys.py
@@ -537,8 +537,8 @@ def linearize(self, x0, u0, t=0, params=None, eps=1e-6,
         u0 = _concatenate_list_elements(u0, 'u0')
 
         # Figure out dimensions if they were not specified.
-        nstates = _find_size(self.nstates, x0, "states")
-        ninputs = _find_size(self.ninputs, u0, "inputs")
+        nstates = _find_size(self.nstates, x0, "x0")
+        ninputs = _find_size(self.ninputs, u0, "u0")
 
         # Convert x0, u0 to arrays, if needed
         if np.isscalar(x0):
@@ -1468,7 +1468,8 @@ def input_output_response(
         # Use the input time points as the output time points
         t_eval = T
 
-    # If we were passed a list of input, concatenate them (w/ broadcast)
+    # If we were passed a list of inputs, concatenate them (w/ broadcast)
+    # TODO: call _concatenate_list_elements
     if isinstance(U, (tuple, list)) and len(U) != ntimepts:
         U_elements = []
         for i, u in enumerate(U):
@@ -1492,11 +1493,21 @@ def input_output_response(
         # Save the newly created input vector
         U = np.vstack(U_elements)
 
+    # Figure out the number of inputs
+    # TODO: call _concatenate_list_elements?
+    if sys.ninputs is None:
+        if isinstance(U, np.ndarray):
+            ninputs = U.shape[0] if U.size > 1 else U.size
+        else:
+            ninputs = 1
+    else:
+        ninputs = sys.ninputs
+
     # Make sure the input has the right shape
-    if sys.ninputs is None or sys.ninputs == 1:
+    if ninputs is None or ninputs == 1:
         legal_shapes = [(ntimepts,), (1, ntimepts)]
     else:
-        legal_shapes = [(sys.ninputs, ntimepts)]
+        legal_shapes = [(ninputs, ntimepts)]
 
     U = _check_convert_array(
         U, legal_shapes, 'Parameter ``U``: ', squeeze=False)
@@ -1522,15 +1533,19 @@ def input_output_response(
     X0 = _check_convert_array(
         X0, [(nstates,), (nstates, 1)], 'Parameter ``X0``: ', squeeze=True)
 
+    # Update the parameter values (prior to evaluating outfcn)
+    sys._update_params(params)
+
     # Figure out the number of outputs
-    if sys.noutputs is None:
-        # Evaluate the output function to find number of outputs
-        noutputs = np.shape(sys._out(T[0], X0, U[:, 0]))[0]
+    if sys.outfcn is None:
+        noutputs = nstates if sys.noutputs is None else sys.noutputs
     else:
-        noutputs = sys.noutputs
+        noutputs = np.shape(sys._out(T[0], X0, U[:, 0]))[0]
 
-    # Update the parameter values
-    sys._update_params(params)
+    if sys.noutputs is not None and sys.noutputs != noutputs:
+        raise RuntimeError(
+            f"inconsistent size of outputs; system specified {sys.noutputs}, "
+            f"output function returned {noutputs}")
 
     #
     # Define a function to evaluate the input at an arbitrary time
@@ -1737,9 +1752,9 @@ def find_eqpt(sys, x0, u0=None, y0=None, t=0, params=None,
     from scipy.optimize import root
 
     # Figure out the number of states, inputs, and outputs
-    nstates = _find_size(sys.nstates, x0, "states")
-    ninputs = _find_size(sys.ninputs, u0, "inputs")
-    noutputs = _find_size(sys.noutputs, y0, "outputs")
+    nstates = _find_size(sys.nstates, x0, "x0")
+    ninputs = _find_size(sys.ninputs, u0, "u0")
+    noutputs = _find_size(sys.noutputs, y0, "y0")
 
     # Convert x0, u0, y0 to arrays, if needed
     if np.isscalar(x0):
@@ -1982,23 +1997,24 @@ def linearize(sys, xeq, ueq=None, t=0, params=None, **kw):
     return sys.linearize(xeq, ueq, t=t, params=params, **kw)
 
 
-def _find_size(sysval, vecval, label):
+def _find_size(sysval, vecval, name="system component"):
     """Utility function to find the size of a system parameter
 
     If both parameters are not None, they must be consistent.
     """
     if hasattr(vecval, '__len__'):
         if sysval is not None and sysval != len(vecval):
             raise ValueError(
-                f"inconsistent information for number of {label}")
+                f"inconsistent information to determine size of {name}; "
+                f"expected {sysval} values, received {len(vecval)}")
         return len(vecval)
     # None or 0, which is a valid value for "a (sysval, ) vector of zeros".
     if not vecval:
         return 0 if sysval is None else sysval
     elif sysval == 1:
         # (1, scalar) is also a valid combination from legacy code
         return 1
-    raise ValueError(f"can't determine number of {label}")
+    raise ValueError(f"can't determine size of {name}")
 
 
 # Function to create an interconnected system
diff --git a/control/tests/iosys_test.py b/control/tests/iosys_test.py
@@ -1422,7 +1422,7 @@ def test_operand_badtype(self, C, op):
     def test_neg_badsize(self):
         # Create a system of unspecified size
         sys = ct.NonlinearIOSystem(lambda t, x, u, params: -x)
-        with pytest.raises(ValueError, match="Can't determine"):
+        with pytest.raises(ValueError, match="Can't determine number"):
             -sys
 
     def test_bad_signal_list(self):
@@ -2077,6 +2077,7 @@ def test_find_eqpt(x0, ix, u0, iu, y0, iy, dx0, idx, dt, x_expect, u_expect):
     np.testing.assert_allclose(np.array(xeq), x_expect, atol=1e-6)
     np.testing.assert_allclose(np.array(ueq), u_expect, atol=1e-6)
 
+
 def test_iosys_sample():
     csys = ct.rss(2, 1, 1)
     dsys = csys.sample(0.1)
@@ -2087,3 +2088,42 @@ def test_iosys_sample():
     dsys = ct.sample_system(csys, 0.1)
     assert isinstance(dsys, ct.StateSpace)
     assert dsys.dt == 0.1
+
+
+# Make sure that we can determine system sizes automatically
+def test_find_size():
+    # Create a nonlinear system with no size information
+    sys = ct.nlsys(
+        lambda t, x, u, params: -x + u,
+        lambda t, x, u, params: x[:1])
+
+    # Run a simulation with size set by parameters
+    timepts = np.linspace(0, 1)
+    resp = ct.input_output_response(sys, timepts, [0, 1], X0=[0, 0])
+    assert resp.states.shape[0] == 2
+    assert resp.inputs.shape[0] == 2
+    assert resp.outputs.shape[0] == 1
+
+    #
+    # Make sure we get warnings if things are inconsistent
+    #
+
+    # Define a system of fixed size
+    sys = ct.nlsys(
+        lambda t, x, u, params: -x + u,
+        lambda t, x, u, params: x[:1],
+        inputs=2, states=2)
+    
+    with pytest.raises(ValueError, match="inconsistent .* size of X0"):
+        resp = ct.input_output_response(sys, timepts, [0, 1], X0=[0, 0, 1])
+
+    with pytest.raises(ValueError, match=".*U.* Wrong shape"):
+        resp = ct.input_output_response(sys, timepts, [0, 1, 2], X0=[0, 0])
+
+    with pytest.raises(RuntimeError, match="inconsistent size of outputs"):
+        sys = ct.nlsys(
+            lambda t, x, u, params: -x + u,
+            lambda t, x, u, params: x[:1],
+            inputs=2, states=2, outputs=2)
+        resp = ct.input_output_response(sys, timepts, [0, 1], X0=[0, 0])
+    
