new version

Author: rssalessio

examples/1_example.py

@@ -1,78 +1,79 @@
 import numpy as np
 import matplotlib.pyplot as plt
-import control as ctl
+import scipy.signal as scipysig
 from vrft import *
 
 def generateNoise(t):
 	omega = 2*np.pi*100
 	xi = 0.9
+	dt = t[1] - t[0]
 	noise =  np.random.normal(0,0.1,t.size)
+	tf = scipysig.TransferFunction([10*omega**2], [1, 2*xi*omega, omega**2])
 	# Second order system
-	yn,t,x = ctl.lsim(ctl.tf([10*omega**2], [1, 2*xi*omega, omega**2]), \
-		noise, t)
+	_, yn, _ = scipysig.lsim(tf, noise, t)
 	return yn
 
 #Generate time and u(t) signals
 t_start = 0
 t_end = 10
 t_step = 1e-2
 t = np.arange(t_start, t_end, t_step)
-u = np.ones(len(t)).tolist()
+u = np.ones(len(t))
 u[200:400] = np.zeros(200)
 u[600:800] = np.zeros(200)
 
 #Experiment
 num = [0.5]
 den = [1, -0.9]
-sys = ctl.tf(num, den, t_step)
-y,t,x= ctl.lsim(sys, u, t)
+sys = ExtendedTF(num, den, dt=t_step)
+t, y = scipysig.dlsim(sys, u, t)
+y = y[:, 0]
 y += generateNoise(t)
-data = vrft.iddata(y[0],u,t_step,[0])
+data = iddata(y, u, t_step, [0])
+
 
 #Reference Model
-refModel = ctl.tf([0.6], [1, -0.4], t_step)
+refModel = ExtendedTF([0.6], [1, -0.4], dt=t_step)
 
 #PI Controller
-base = [ctl.tf([1], [1],t_step),
-	ctl.tf([1, 0], [1, -1],t_step)]
+base = [ExtendedTF([1], [1, -1], dt=t_step),
+	    ExtendedTF([1, 0], [1, -1], dt=t_step)]
 
 #Experiment filter
-omega = 2*np.pi*0.1
-L =  ctl.tf([1], [1/omega, 1])
-L =  ctl.sample_system(L, 0.01)
-
+L = refModel * (1 -  refModel)
 #VRFT
-C, theta, r = vrft.vrftAlgorithm(data, refModel, base, L)
+theta, r, _, _, C = compute_vrft(data, refModel, base, L)
 
 #Obtained controller
-print "Controller:", C
-L = C*sys
-L = L/(1+L)
+print("Controller: {}".format(C))
 
-L = L.minreal()
-#this is due to a bug in the control library
-L = ctl.tf(L.num, L.den, t_step)
+L = C * sys
+L = feedback(L)
 
-print "Theta:", theta
+print("Theta: {}".format(theta))
 
 #Analysis
-yr,t = ctl.step(refModel, t)
-yc,t = ctl.step(L, t)
-ys,t = ctl.step(sys, t)
-
-
+t = t[:len(r)]
+u = np.ones(len(t))
+_, yr = scipysig.dlsim(refModel, u, t)
+_, yc = scipysig.dlsim(L, u, t)
+_, ys = scipysig.dlsim(sys, u, t)
+
+yr = np.array(yr).flatten()
+ys = np.array(ys).flatten()
+yc = np.array(yc).flatten()
 fig, ax = plt.subplots(4, sharex=True)
-ax[0].plot(t,yr[0],label='Ref System')
-ax[0].plot(t,yc[0], label='CL System')
+ax[0].plot(t, yr,label='Ref System')
+ax[0].plot(t, yc, label='CL System')
 ax[0].set_title('Systems response')
 ax[0].grid(True)
-ax[1].plot(t,ys[0], label='OL System')
+ax[1].plot(t, ys, label='OL System')
 ax[1].set_title('OL Systems response')
 ax[1].grid(True)
-ax[2].plot(t,y[0])
+ax[2].plot(t, y[:len(r)])
 ax[2].grid(True)
 ax[2].set_title('Experiment data')
-ax[3].plot(t,r)
+ax[3].plot(t, r)
 ax[3].grid(True)
 ax[3].set_title('Virtual Reference')
 

setup.py

@@ -1,20 +1,19 @@
 from setuptools import setup
 
 setup(name = 'vrft',
-	version = '0.0.2',
+	version = '0.0.3',
 	description = 'VRFT Python Library',
 	long_description = 'VRFT Python Library',
 	keywords = 'VRFT Virtual Reference Feedback Tuning Adaptive Control',
 	url = 'https://github.com/rssalessio/PythonVRFT/',
 	author = 'Alessio Russo',
-	author_email = 'alessio.russo@rapyuta-robotics.com',
+	author_email = 'alessior@kth.se',
 	license='GPL3',
-	packages=['vrft', 'vrft.tests', 'vrft.utilities', 'vrft.vrft'],
+	packages=['vrft', 'test', 'vrft.utilities', 'vrft.vrft'],
 	zip_safe=False,
 	install_requires = [
 		'scipy',
 		'numpy',
-		'control',
 	],
 	test_suite = 'nose.collector',
 	test_requires = ['nose']

test/__init__.py

@@ -0,0 +1,60 @@
+from unittest import TestCase
+from vrft.utilities.iddata import iddata
+import numpy as np
+
+class TestIDData(TestCase):
+    def test_type(self):
+        a = iddata(0.0, 0.0, 0.0)
+        with self.assertRaises(ValueError):
+            a.checkData()
+
+        a =  iddata(0.0, [1], 0.0)
+        with self.assertRaises(ValueError):
+            a.checkData()
+
+        a = iddata(np.zeros(10), 1, 0.0)
+        with self.assertRaises(ValueError):
+            a.checkData()
+
+        a = iddata([0 for i in range(10)], [0 for i in range(10)], 1.0)
+        self.assertTrue(a.checkData())
+
+        a = iddata(np.zeros(10), np.zeros(10), 1.0)
+        self.assertTrue(a.checkData())
+
+    def test_size(self):
+        a = iddata(np.zeros(10), np.zeros(10), 0.0)
+        self.assertEqual(len(a.y), 10)
+        self.assertEqual(len(a.u), 10)
+        self.assertEqual(len(a.y), len(a.u))
+
+        a = iddata([0 for i in range(10)], [1 for i in range(0,10)], 0.0)
+        self.assertEqual(len(a.y), 10)
+        self.assertEqual(len(a.u), 10)
+        self.assertEqual(len(a.y), len(a.u))
+
+        a = iddata(np.zeros(10), np.zeros(9), 0.0)
+        with self.assertRaises(ValueError):
+            a.checkData()
+
+        a = iddata(np.zeros(8), np.zeros(9), 0.0)
+        with self.assertRaises(ValueError):
+            a.checkData()
+
+
+    def test_sampling_time(self):
+        a = iddata(np.zeros(10), np.zeros(10), 0.0)
+        with self.assertRaises(ValueError):
+            a.checkData()
+
+        a = iddata(np.zeros(10), np.zeros(10), 1e-9)
+        with self.assertRaises(ValueError):
+            a.checkData()
+
+        a = iddata(np.zeros(10), np.zeros(10), -0.1)
+        with self.assertRaises(ValueError):
+            a.checkData()
+
+        a = iddata(np.zeros(10), np.zeros(10), 0.1)
+        self.assertTrue(a.checkData())
+

test/test_iddata.py

@@ -0,0 +1,65 @@
+from unittest import TestCase
+from vrft.utilities.iddata import *
+from vrft.utilities.utils import *
+from vrft.vrft.vrft_algo import *
+import numpy as np
+import scipy.signal as scipysig
+
+class TestReference(TestCase):
+    def test_virtualReference(self):
+        # wrong system
+        with self.assertRaises(ValueError):
+            virtualReference(1, 1, 0)
+
+        # cant be constant the system
+        with self.assertRaises(ValueError):
+            virtualReference([1],[1], 0)
+
+        # cant be constant the system
+        with self.assertRaises(ValueError):
+            virtualReference(np.array(2), np.array(3), 0)
+
+        # wrong data
+        with self.assertRaises(ValueError):
+            virtualReference([1], [1, 1], 0)
+
+        t_start = 0
+        t_end = 10
+        t_step = 1e-2
+        t = np.arange(t_start, t_end, t_step)
+        u = np.ones(len(t)).tolist()
+
+        num = [0.1]
+        den = [1, -0.9]
+        sys = scipysig.TransferFunction(num, den, dt=t_step)
+        t,y = scipysig.dlsim(sys, u, t)
+        y = y[:,0]
+        data = iddata(y,u,t_step,[0,0])
+        #wrong initial conditions
+        with self.assertRaises(ValueError):
+            virtualReference(data, num, den)
+
+        #wrong initial conditions
+        data = iddata(y,u,t_step,[0,0,0])
+        with self.assertRaises(ValueError):
+            virtualReference(data, num, den)
+
+        #test good data, first order
+        data = iddata(y,u,t_step,[0])
+
+        r, _ = virtualReference(data, num, den)
+
+        for i in range(len(r)):
+            self.assertTrue(np.isclose(r[i], u[i]))
+
+
+        num = [0, 1-1.6+0.63]
+        den = [1, -1.6, 0.63]
+        sys = scipysig.TransferFunction(num, den, dt=t_step)
+        t, y = scipysig.dlsim(sys, u, t)
+        y = y[:,0]
+        data = iddata(y,u,t_step,[0,0])
+        #test second order
+        r, _ = virtualReference(data, num, den)
+        for i in range(len(r)):
+            self.assertTrue(np.isclose(r[i], u[i]))

test/test_reference.py

@@ -0,0 +1,55 @@
+from unittest import TestCase
+from vrft.utilities.utils import *
+import numpy as np
+
+class TestTF(TestCase):
+    def test_checkSystem(self):
+        a = [1, 0, 1]
+        b = [1, 0, 2]
+        self.assertTrue(checkSystem(a,b))
+
+        b = [1, 0, 2, 4]
+        self.assertTrue(checkSystem(a,b))
+
+        a = [1]
+        self.assertTrue(checkSystem(a,b))
+
+        a = [1, 0, 1]
+        b = [1,0]
+        with self.assertRaises(ValueError):
+            checkSystem(a,b)
+
+        b = [1]
+        with self.assertRaises(ValueError):
+            checkSystem(a,b)
+
+    def test_systemOrder(self):
+        with self.assertRaises(ValueError):
+            systemOrder(0, 0)
+
+        with self.assertRaises(ValueError):
+            systemOrder(1, 0)
+
+        with self.assertRaises(ValueError):
+            systemOrder([0], 0)
+
+        with self.assertRaises(ValueError):
+            systemOrder([0], [0])
+
+        with self.assertRaises(ValueError):
+            systemOrder([0, 0], [0, 0])
+
+        with self.assertRaises(ValueError):
+            systemOrder([0], [0, 0])
+
+
+        self.assertEqual(systemOrder([1],[1]), (0, 0))
+        self.assertEqual(systemOrder([1, 1],[1, 1]), (1,1))
+        self.assertEqual(systemOrder([1, 1, 3],[1, 1]), (2,1))
+        self.assertEqual(systemOrder([1, 1, 3],[1]), (2,0))
+        self.assertEqual(systemOrder([1, 1],[1, 1, 1]), (1,2))
+        self.assertEqual(systemOrder([1],[1, 1, 1]), (0,2))
+        self.assertEqual(systemOrder([0, 1],[1, 1, 1]), (0,2))
+        self.assertEqual(systemOrder([0,0,1],[1, 1, 1]), (0,2))
+        self.assertEqual(systemOrder([0,0,1],[0, 1, 1, 1]), (0,2))
+        self.assertEqual(systemOrder([0,0,1],[0, 0, 1, 1, 1]), (0,2))

test/test_tf.py

@@ -0,0 +1,33 @@
+from unittest import TestCase
+from vrft.utilities.iddata import *
+from vrft.vrft.vrft_algo import *
+from vrft.utilities.utils import ExtendedTF
+import numpy as np
+import scipy.signal as scipysig
+
+class TestVRFT(TestCase):
+    def test_vrft(self):
+        t_start = 0
+        t_end = 10
+        t_step = 1e-2
+        t = np.arange(t_start, t_end, t_step)
+        u = np.ones(len(t)).tolist()
+
+        num = [0.1]
+        den = [1, -0.9]
+        sys = scipysig.TransferFunction(num, den, dt=t_step)
+        t, y = scipysig.dlsim(sys, u, t)
+        y = y[:,0]
+        data = iddata(y,u,t_step,[0])
+
+        refModel = ExtendedTF([0.2], [1, -0.8], dt=t_step)
+
+        control = [ExtendedTF([1], [1,0], dt=t_step),
+                ExtendedTF([1], [1,0,0], dt=t_step),
+                ExtendedTF([1], [1,0,0,0], dt=t_step),
+                ExtendedTF([1, 0], [1,1], dt=t_step)]
+
+        theta, _, _, loss, _ = compute_vrft(data, refModel, control, refModel * (1-refModel))
+
+
+

test/test_vrft.py

@@ -1,4 +1,3 @@
-import utilities
-from utilities import *
-import vrft
-from vrft import *
+
+from .utilities import *
+from .vrft import *