allow creation of NonlinearIOSystem via ss()

murrayrm · murrayrm · commit ad714fed47f1 · 2022-04-01T21:19:49.000-07:00
diff --git a/control/iosys.py b/control/iosys.py
@@ -31,6 +31,7 @@
 import copy
 from warnings import warn
 
+from .lti import LTI
 from .namedio import _NamedIOSystem, _process_signal_list
 from .statesp import StateSpace, tf2ss, _convert_to_statespace
 from .statesp import _ss, _rss_generate
@@ -2252,12 +2253,17 @@ def ss(*args, **kwargs):
 
     Create a state space system.
 
-    The function accepts either 1, 4 or 5 parameters:
+    The function accepts either 1, 2, 4 or 5 parameters:
 
     ``ss(sys)``
         Convert a linear system into space system form. Always creates a
         new system, even if sys is already a state space system.
 
+    ``ss(updfcn, outfucn)```
+        Create a nonlinear input/output system with update function ``updfcn``
+        and output function ``outfcn``.  See :class:`NonlinearIOSystem` for
+        more information.
+
     ``ss(A, B, C, D)``
         Create a state space system from the matrices of its state and
         output equations:
@@ -2280,6 +2286,10 @@ def ss(*args, **kwargs):
         Everything that the constructor of :class:`numpy.matrix` accepts is
         permissible here too.
 
+    ``ss(args, inputs=['u1', ..., 'up'], outputs=['y1', ..., 'yq'],
+         states=['x1', ..., 'xn'])
+        Create a system with named input, output, and state signals.
+
     Parameters
     ----------
     sys : StateSpace or TransferFunction
@@ -2326,6 +2336,12 @@ def ss(*args, **kwargs):
     >>> sys2 = ss(sys_tf)
 
     """
+    # See if this is a nonlinear I/O system
+    if len(args) > 0 and hasattr(args[0], '__call__') and \
+       not isinstance (args[0], (InputOutputSystem, LTI)):
+        # Function as first argument => assume nonlinear IO system
+        return NonlinearIOSystem(*args, **kwargs)
+
     # Extract the keyword arguments needed for StateSpace (via _ss)
     ss_kwlist = ('dt', 'remove_useless_states')
     ss_kwargs = {}
@@ -2334,7 +2350,7 @@ def ss(*args, **kwargs):
             ss_kwargs[kw] = kwargs.pop(kw)
 
     # Create the statespace system and then convert to I/O system
-    sys = _ss(*args, keywords=ss_kwargs)
+    sys = _ss(*args, **ss_kwargs)
     return LinearIOSystem(sys, **kwargs)
 
 
diff --git a/control/tests/iosys_test.py b/control/tests/iosys_test.py
@@ -130,9 +130,10 @@ def test_iosys_print(self, tsys, capsys):
         print(ios_linearized)
 
     @noscipy0
-    def test_nonlinear_iosys(self, tsys):
+    @pytest.mark.parametrize("ss", [ios.NonlinearIOSystem, ct.ss])
+    def test_nonlinear_iosys(self, tsys, ss):
         # Create a simple nonlinear I/O system
-        nlsys = ios.NonlinearIOSystem(predprey)
+        nlsys = ss(predprey)
         T = tsys.T
 
         # Start by simulating from an equilibrium point
@@ -159,7 +160,7 @@ def test_nonlinear_iosys(self, tsys):
             np.reshape(linsys.C @ np.reshape(x, (-1, 1))
                        + linsys.D @ np.reshape(u, (-1, 1)),
                        (-1,))
-        nlsys = ios.NonlinearIOSystem(nlupd, nlout, inputs=1, outputs=1)
+        nlsys = ss(nlupd, nlout, inputs=1, outputs=1)
 
         # Make sure that simulations also line up
         T, U, X0 = tsys.T, tsys.U, tsys.X0
@@ -1775,3 +1776,21 @@ def test_nonuniform_timepts():
     t_even, y_even = ct.input_output_response(
         sys, noufpts, nonunif, t_eval=unifpts)
     np.testing.assert_almost_equal(y_unif, y_even, decimal=6)
+
+
+def test_ss_nonlinear():
+    """Test ss() for creating nonlinear systems"""
+    secord = ct.ss(secord_update, secord_output, inputs='u', outputs='y',
+                   states = ['x1', 'x2'], name='secord')
+    assert secord.name == 'secord'
+    assert secord.input_labels == ['u']
+    assert secord.output_labels == ['y']
+    assert secord.state_labels == ['x1', 'x2']
+
+    # Make sure that optional keywords are allowed
+    secord = ct.ss(secord_update, secord_output, dt=True)
+    assert ct.isdtime(secord)
+
+    # Make sure that state space keywords are flagged
+    with pytest.raises(TypeError, match="unrecognized keyword"):
+        ct.ss(secord_update, remove_useless_states=True)
diff --git a/control/tests/timeresp_test.py b/control/tests/timeresp_test.py
@@ -875,7 +875,7 @@ def test_time_vector(self, tsystem, fun, squeeze, matarrayout):
                 kw['U'] = np.vstack([np.sin(t) for i in range(sys.ninputs)])
         elif fun == forced_response and isctime(sys, strict=True):
             pytest.skip("No continuous forced_response without time vector.")
-        if hasattr(sys, "nstates"):
+        if hasattr(sys, "nstates") and sys.nstates is not None:
             kw['X0'] = np.arange(sys.nstates) + 1
         if sys.ninputs > 1 and fun in [step_response, impulse_response]:
             kw['input'] = 1
diff --git a/control/xferfcn.py b/control/xferfcn.py
@@ -61,6 +61,7 @@
 from re import sub
 from .lti import LTI, common_timebase, isdtime, _process_frequency_response
 from .exception import ControlMIMONotImplemented
+from .namedio import _NamedIOSystem, _process_signal_list
 from . import config
 
 __all__ = ['TransferFunction', 'tf', 'ss2tf', 'tfdata']
@@ -70,7 +71,7 @@
 _xferfcn_defaults = {}
 
 
-class TransferFunction(LTI):
+class TransferFunction(LTI, _NamedIOSystem):
     """TransferFunction(num, den[, dt])
 
     A class for representing transfer functions.
