append _linearize for system name + unit tests

murrayrm · murrayrm · commit e343a33353ae · 2020-12-31T21:55:59.000-08:00
diff --git a/control/iosys.py b/control/iosys.py
@@ -551,7 +551,7 @@ def linearize(self, x0, u0, t=0, params={}, eps=1e-6,
             A[:, i] = (self._rhs(t, x0 + dx, u0) - F0) / eps
             C[:, i] = (self._out(t, x0 + dx, u0) - H0) / eps
 
-            # Perturb each of the input variables and compute linearization
+        # Perturb each of the input variables and compute linearization
         for i in range(ninputs):
             du = np.zeros((ninputs,))
             du[i] = eps
@@ -565,6 +565,8 @@ def linearize(self, x0, u0, t=0, params={}, eps=1e-6,
 
         # Set the names the system, inputs, outputs, and states
         if copy:
+            if name is None:
+                linsys.name = self.name + "_linearized"
             linsys.ninputs, linsys.input_index = self.ninputs, \
                 self.input_index.copy()
             linsys.noutputs, linsys.output_index = \
@@ -1804,9 +1806,13 @@ def linearize(sys, xeq, ueq=[], t=0, params={}, **kw):
         for the system as default values, overriding internal defaults.
     copy : bool, Optional
         If `copy` is True, copy the names of the input signals, output signals,
-        and states to the linearized system.
+        and states to the linearized system.  If `name` is not specified,
+        the system name is set to the input system name with the string
+        '_linearized' appended.
     name : string, optional
-        Set the name of the linearized system.
+        Set the name of the linearized system.  If not specified and if `copy`
+        is `False`, a generic name <sys[id]> is generated with a unique
+        integer id.
 
     Returns
     -------
diff --git a/control/tests/iosys_test.py b/control/tests/iosys_test.py
@@ -167,7 +167,22 @@ def test_nonlinear_iosys(self, tsys):
         np.testing.assert_array_almost_equal(lti_t, ios_t)
         np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.)
 
-    def test_linearize(self, tsys):
+    @pytest.fixture
+    def kincar(self):
+        # Create a simple nonlinear system to check (kinematic car)
+        def kincar_update(t, x, u, params):
+            return np.array([np.cos(x[2]) * u[0], np.sin(x[2]) * u[0], u[1]])
+
+        def kincar_output(t, x, u, params):
+            return np.array([x[0], x[1]])
+
+        return ios.NonlinearIOSystem(
+            kincar_update, kincar_output,
+            inputs = ['v', 'phi'],
+            outputs = ['x', 'y'],
+            states = ['x', 'y', 'theta'])
+
+    def test_linearize(self, tsys, kincar):
         # Create a single input/single output linear system
         linsys = tsys.siso_linsys
         iosys = ios.LinearIOSystem(linsys)
@@ -180,13 +195,7 @@ def test_linearize(self, tsys):
         np.testing.assert_array_almost_equal(linsys.D, linearized.D)
 
         # Create a simple nonlinear system to check (kinematic car)
-        def kincar_update(t, x, u, params):
-            return np.array([np.cos(x[2]) * u[0], np.sin(x[2]) * u[0], u[1]])
-
-        def kincar_output(t, x, u, params):
-            return np.array([x[0], x[1]])
-
-        iosys = ios.NonlinearIOSystem(kincar_update, kincar_output)
+        iosys = kincar
         linearized = iosys.linearize([0, 0, 0], [0, 0])
         np.testing.assert_array_almost_equal(linearized.A, np.zeros((3,3)))
         np.testing.assert_array_almost_equal(
@@ -196,6 +205,29 @@ def kincar_output(t, x, u, params):
         np.testing.assert_array_almost_equal(linearized.D, np.zeros((2,2)))
 
 
+    def test_linearize_named_signals(self, kincar):
+        # Full form of the call
+        linearized = kincar.linearize([0, 0, 0], [0, 0], copy=True,
+                                      name='linearized')
+        assert linearized.name == 'linearized'
+        assert linearized.find_input('v') == 0
+        assert linearized.find_input('phi') == 1
+        assert linearized.find_output('x') == 0
+        assert linearized.find_output('y') == 1
+        assert linearized.find_state('x') == 0
+        assert linearized.find_state('y') == 1
+        assert linearized.find_state('theta') == 2
+
+        # If we copy signal names w/out a system name, append '_linearized'
+        linearized = kincar.linearize([0, 0, 0], [0, 0], copy=True)
+        assert linearized.name == kincar.name + '_linearized'
+
+        # If copy is False, signal names should not be copied
+        lin_nocopy = kincar.linearize(0, 0, copy=False)
+        assert lin_nocopy.find_input('v') is None
+        assert lin_nocopy.find_output('x') is None
+        assert lin_nocopy.find_state('x') is None
+
     @noscipy0
     def test_connect(self, tsys):
         # Define a couple of (linear) systems to interconnection
