BugFix: tf2ss now handles static gains

roryyorke · roryyorke · commit a44305b1c056 · 2017-01-04T21:22:27.000+02:00
Check for static-gain (i.e., constant) transfer function matrix, and
handle specially.

Added unit test for a SISO and a MIMO plant.
diff --git a/control/statesp.py b/control/statesp.py
@@ -10,6 +10,7 @@
 
 # Python 3 compatibility (needs to go here)
 from __future__ import print_function
+from __future__ import division # for _convertToStateSpace
 
 """Copyright (c) 2010 by California Institute of Technology
 All rights reserved.
@@ -638,6 +639,7 @@ def _convertToStateSpace(sys, **kw):
     """
 
     from .xferfcn import TransferFunction
+    import itertools
     if isinstance(sys, StateSpace):
         if len(kw):
             raise TypeError("If sys is a StateSpace, _convertToStateSpace \
@@ -657,18 +659,45 @@ def _convertToStateSpace(sys, **kw):
             num, den = sys._common_den()
             # Make a list of the orders of the denominator polynomials.
             index = [len(den) - 1 for i in range(sys.outputs)]
-            # Repeat the common denominator along the rows.
-            den = array([den for i in range(sys.outputs)])
-            #! TODO: transfer function to state space conversion is still buggy!
-            #print num
-            #print shape(num)
-            ssout = td04ad('R',sys.inputs, sys.outputs, index, den, num,tol=0.0)
-
-            states = ssout[0]
-            return StateSpace(ssout[1][:states, :states],
-                ssout[2][:states, :sys.inputs],
-                ssout[3][:sys.outputs, :states],
-                ssout[4], sys.dt)
+
+            if index.count(0):
+                # all TFM entries are static gains
+                # if any entry in index is 0, td0ad raises:
+                # ValueError: failed to create
+                #   intent(cache|hide)|optional array-- must have
+                #   defined dimensions but got (*,0,)
+                # (where "*" varies according to the system size).  This
+                # suggests it's a problem in Slycot rather than
+                # SLICOT.
+                # Regardless, as of 2017-01-01 (commit 32f13bc), all
+                # entries of index have the same value.  The check
+                # immediately below is in case this ever changes,
+                # e.g., common denominator found per row or per column
+                # (which seems like the right thing to do).  If such a
+                # change *IS* made, then we might have a row (or
+                # column) of static gains, and either some SS assembly
+                # gymnastics will be required here, or td0ad must be
+                # fixed.
+                if index.count(0) != len(index):
+                    raise RuntimeError("require all or no index entries to be 0")
+
+                D = empty((sys.outputs,sys.inputs),dtype=float)
+                for i,j in itertools.product(range(sys.outputs),range(sys.inputs)):
+                    D[i,j] = sys.num[i][j][0] / sys.den[i][j][0]
+                return StateSpace([], [], [], D, sys.dt)
+            else:
+                # Repeat the common denominator along the rows.
+                den = array([den for i in range(sys.outputs)])
+                #! TODO: transfer function to state space conversion is still buggy!
+                #print num
+                #print shape(num)
+                ssout = td04ad('R',sys.inputs, sys.outputs, index, den, num,tol=0.0)
+
+                states = ssout[0]
+                return StateSpace(ssout[1][:states, :states],
+                    ssout[2][:states, :sys.inputs],
+                    ssout[3][:sys.outputs, :states],
+                    ssout[4], sys.dt)
         except ImportError:
             # If slycot is not available, use signal.lti (SISO only)
             if (sys.inputs != 1 or sys.outputs != 1):
diff --git a/control/tests/convert_test.py b/control/tests/convert_test.py
@@ -184,6 +184,27 @@ def testConvertMIMO(self):
         if (not slycot_check()):
             self.assertRaises(TypeError, control.tf2ss, tfcn)
 
+    def testTf2ssStatic(self):
+        """Regression: tf2ss for static gains"""
+        import control
+
+        gsiso = control.tf2ss(control.tf(23, 46))
+        self.assertEqual(0, gsiso.states)
+        self.assertEqual(1, gsiso.inputs)
+        self.assertEqual(1, gsiso.outputs)
+        # in all cases ratios are exactly representable, so assert_array_equal is fine
+        np.testing.assert_array_equal([[0.5]], gsiso.D)
+
+        if slycot_check():
+            # 2x3 TFM
+            gmimo = control.tf2ss(control.tf([[ [23],   [3],  [5] ], [ [-1],  [0.125],  [101.3] ]],
+                                             [[ [46], [0.1], [80] ], [  [2],   [-0.1],      [1] ]]))
+            self.assertEqual(0, gmimo.states)
+            self.assertEqual(3, gmimo.inputs)
+            self.assertEqual(2, gmimo.outputs)
+            d = np.matrix([[0.5, 30, 0.0625], [-0.5, -1.25, 101.3]])
+            np.testing.assert_array_equal(d, gmimo.D)
+
 
 def suite():
    return unittest.TestLoader().loadTestsFromTestCase(TestConvert)
