trunk/pygtk/test.py

import unittest
import ascpy
import math
import os, subprocess

class CUnit(unittest.TestCase):
    def setUp(self):
        self.cunitexe = "../base/generic/test/test"
    
    def testcunittests(self):
        res = os.system(self.cunitexe)
        if res:
            raise RuntimeError("CUnit tests failed (returned %d -- run %s for details)" % (res,self.cunitexe))
        else:
            print "CUnit returned %s" % res

class Ascend(unittest.TestCase):

    def setUp(self):
        import ascpy
        self.L = ascpy.Library()
    
    def tearDown(self):
        self.L.clear()
        del self.L

    def testloading(self):
        pass

    def testsystema4l(self):
        self.L.load('system.a4l')

    def testatomsa4l(self):
        self.L.load('atoms.a4l')

    def testlog10(self):
        self.L.load('johnpye/testlog10.a4c')
        T = self.L.findType('testlog10')
        M = T.getSimulation('sim')
        M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())   
        M.run(T.getMethod('self_test'))     

    def testListIntegrators(self):
        I = ascpy.Integrator.getEngines()
        s1 = sorted([str(i) for i in I.values()])
        s2 = sorted(['IDA','LSODE'])
        assert s1==s2

    # this routine is reused by both testIDA and testLSODE
    def _testIntegrator(self,integratorname):
        self.L.load('johnpye/shm.a4c')
        M = self.L.findType('shm').getSimulation('sim')
        print M.sim.getChildren()
        assert float(M.sim.x) == 10.0
        assert float(M.sim.v) == 0.0
        t_end = math.pi

        I = ascpy.Integrator(M)
        I.setReporter(ascpy.IntegratorReporterNull(I))
        I.setEngine(integratorname);
        I.setLinearTimesteps(ascpy.Units("s"), 0.0, t_end, 100);
        I.setMinSubStep(0.0005); # these limits are required by IDA at present (numeric diff)
        I.setMaxSubStep(0.02);
        I.setInitialSubStep(0.001);
        I.setMaxSubSteps(200);
        if(integratorname=='IDA'):
            I.setParameter('autodiff',False)
        I.analyse();
        I.solve();
        print "At end of simulation,"
        print "x = %f" % M.sim.x
        print "v = %f" % M.sim.v
        assert abs(float(M.sim.x) + 10) < 1e-2
        assert abs(float(M.sim.v)) < 1e-2
        assert I.getNumObservedVars() == 3

    def testInvalidIntegrator(self):
        self.L.load('johnpye/shm.a4c')
        M = self.L.findType('shm').getSimulation('sim')
        I = ascpy.Integrator(M)
        try:
            I.setEngine('___NONEXISTENT____')
        except IndexError:
            return
        self.fail("setEngine did not raise error!")

    def testLSODE(self):
        self._testIntegrator('LSODE')

    def testIDA(self):
        self._testIntegrator('IDA')

    def testIDAparameters(self):
        self.L.load('johnpye/shm.a4c')
        M = self.L.findType('shm').getSimulation('sim')
        I = ascpy.Integrator(M)
        I.setEngine('IDA')
        P = I.getParameters()
        for p in P:
            print p.getName(),"=",p.getValue()
        assert len(P)==5
        assert P[0].isStr()
        assert P[0].getName()=="linsolver"
        assert P[0].getValue()=='DENSE'
        assert P[1].getName()=="autodiff"
        assert P[1].getValue()==True
        assert P[4].getName()=="atolvect"
        assert P[4].getBoolValue() == True
        P[1].setBoolValue(False)
        assert P[1].getBoolValue()==False
        I.setParameters(P)
        for p in I.getParameters():
            print p.getName(),"=",p.getValue()
        assert I.getParameterValue('autodiff')==False
        I.setParameter('autodiff',True)
        try:
            v = I.getParameterValue('nonexist')
        except KeyError:
            pass
        else:
            self.fail('Failed to trip invalid Integrator parameter')

    def testIDAdenx(self):
        self.L.load('johnpye/idadenx.a4c')
        M = self.L.findType('idadenx').getSimulation('sim')
        I = ascpy.Integrator(M)
        I.setEngine('IDA')
        I.setReporter(ascpy.IntegratorReporterConsole(I))
        I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11);
        I.setMaxSubStep(0);
        I.setInitialSubStep(0);
        I.setMaxSubSteps(0);
        I.setParameter('autodiff',True)
        I.setParameter('linsolver','DENSE')
        I.analyse()
        I.solve()
        assert abs(float(M.sim.y1) - 5.1091e-08) < 1e-10;
        assert abs(float(M.sim.y2) - 2.0437e-13) < 1e-15;
        assert abs(float(M.sim.y3) - 1.0) < 1e-5;

    def testIDAdenxSPGMR(self):
        self.L.load('johnpye/idadenx.a4c')
        M = self.L.findType('idadenx').getSimulation('sim')
        I = ascpy.Integrator(M)
        I.setEngine('IDA')
        I.setReporter(ascpy.IntegratorReporterConsole(I))
        I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11);
        I.setMaxSubStep(0);
        I.setInitialSubStep(0);
        I.setMaxSubSteps(0);
        I.setParameter('autodiff',True)
        I.setParameter('linsolver','SPGMR')
        I.setParameter('gsmodified',False)
        I.analyse()
        I.solve()
        assert abs(float(M.sim.y1) - 5.1091e-08) < 1e-10;
        assert abs(float(M.sim.y2) - 2.0437e-13) < 1e-15;
        assert abs(float(M.sim.y3) - 1.0) < 1e-5;

    def testIDAkryx(self):
        self.L.load('johnpye/idakryx.a4c')
        M = self.L.findType('idakryx').getSimulation('sim')
        M.build()
        I = ascpy.Integrator(M)
        I.setEngine('IDA')
        I.setReporter(ascpy.IntegratorReporterConsole(I))
        I.setParameter('linsolver','SPGMR')
        I.setParameter('gsmodified',False)
        I.setParameter('autodiff',True)
        I.setParameter('rtol',0)
        I.setParameter('atol',1e-3);
        I.setParameter('atolvect',False)
        I.analyse()
        I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 10);
        print M.sim.udot[1][3];
        I.solve()
        assert 0
    
# move code above down here if you want to temporarily avoid testing it
class NotToBeTested:
    def nothing(self):
        pass
        
if __name__=='__main__':
    unittest.main()
1	import unittest
2	import ascpy
3	import math
4	import os, subprocess
5
6	class CUnit(unittest.TestCase):
7	def setUp(self):
8	self.cunitexe = "../base/generic/test/test"
9
10	def testcunittests(self):
11	res = os.system(self.cunitexe)
12	if res:
13	raise RuntimeError("CUnit tests failed (returned %d -- run %s for details)" % (res,self.cunitexe))
14	else:
15	print "CUnit returned %s" % res
16
17	class Ascend(unittest.TestCase):
18
19	def setUp(self):
20	import ascpy
21	self.L = ascpy.Library()
22
23	def tearDown(self):
24	self.L.clear()
25	del self.L
26
27	def testloading(self):
28	pass
29
30	def testsystema4l(self):
31	self.L.load('system.a4l')
32
33	def testatomsa4l(self):
34	self.L.load('atoms.a4l')
35
36	def testlog10(self):
37	self.L.load('johnpye/testlog10.a4c')
38	T = self.L.findType('testlog10')
39	M = T.getSimulation('sim')
40	M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())
41	M.run(T.getMethod('self_test'))
42
43	def testListIntegrators(self):
44	I = ascpy.Integrator.getEngines()
45	s1 = sorted([str(i) for i in I.values()])
46	s2 = sorted(['IDA','LSODE'])
47	assert s1==s2
48
49	# this routine is reused by both testIDA and testLSODE
50	def _testIntegrator(self,integratorname):
51	self.L.load('johnpye/shm.a4c')
52	M = self.L.findType('shm').getSimulation('sim')
53	print M.sim.getChildren()
54	assert float(M.sim.x) == 10.0
55	assert float(M.sim.v) == 0.0
56	t_end = math.pi
57
58	I = ascpy.Integrator(M)
59	I.setReporter(ascpy.IntegratorReporterNull(I))
60	I.setEngine(integratorname);
61	I.setLinearTimesteps(ascpy.Units("s"), 0.0, t_end, 100);
62	I.setMinSubStep(0.0005); # these limits are required by IDA at present (numeric diff)
63	I.setMaxSubStep(0.02);
64	I.setInitialSubStep(0.001);
65	I.setMaxSubSteps(200);
66	if(integratorname=='IDA'):
67	I.setParameter('autodiff',False)
68	I.analyse();
69	I.solve();
70	print "At end of simulation,"
71	print "x = %f" % M.sim.x
72	print "v = %f" % M.sim.v
73	assert abs(float(M.sim.x) + 10) < 1e-2
74	assert abs(float(M.sim.v)) < 1e-2
75	assert I.getNumObservedVars() == 3
76
77	def testInvalidIntegrator(self):
78	self.L.load('johnpye/shm.a4c')
79	M = self.L.findType('shm').getSimulation('sim')
80	I = ascpy.Integrator(M)
81	try:
82	I.setEngine('___NONEXISTENT____')
83	except IndexError:
84	return
85	self.fail("setEngine did not raise error!")
86
87	def testLSODE(self):
88	self._testIntegrator('LSODE')
89
90	def testIDA(self):
91	self._testIntegrator('IDA')
92
93	def testIDAparameters(self):
94	self.L.load('johnpye/shm.a4c')
95	M = self.L.findType('shm').getSimulation('sim')
96	I = ascpy.Integrator(M)
97	I.setEngine('IDA')
98	P = I.getParameters()
99	for p in P:
100	print p.getName(),"=",p.getValue()
101	assert len(P)==5
102	assert P[0].isStr()
103	assert P[0].getName()=="linsolver"
104	assert P[0].getValue()=='DENSE'
105	assert P[1].getName()=="autodiff"
106	assert P[1].getValue()==True
107	assert P[4].getName()=="atolvect"
108	assert P[4].getBoolValue() == True
109	P[1].setBoolValue(False)
110	assert P[1].getBoolValue()==False
111	I.setParameters(P)
112	for p in I.getParameters():
113	print p.getName(),"=",p.getValue()
114	assert I.getParameterValue('autodiff')==False
115	I.setParameter('autodiff',True)
116	try:
117	v = I.getParameterValue('nonexist')
118	except KeyError:
119	pass
120	else:
121	self.fail('Failed to trip invalid Integrator parameter')
122
123	def testIDAdenx(self):
124	self.L.load('johnpye/idadenx.a4c')
125	M = self.L.findType('idadenx').getSimulation('sim')
126	I = ascpy.Integrator(M)
127	I.setEngine('IDA')
128	I.setReporter(ascpy.IntegratorReporterConsole(I))
129	I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11);
130	I.setMaxSubStep(0);
131	I.setInitialSubStep(0);
132	I.setMaxSubSteps(0);
133	I.setParameter('autodiff',True)
134	I.setParameter('linsolver','DENSE')
135	I.analyse()
136	I.solve()
137	assert abs(float(M.sim.y1) - 5.1091e-08) < 1e-10;
138	assert abs(float(M.sim.y2) - 2.0437e-13) < 1e-15;
139	assert abs(float(M.sim.y3) - 1.0) < 1e-5;
140
141	def testIDAdenxSPGMR(self):
142	self.L.load('johnpye/idadenx.a4c')
143	M = self.L.findType('idadenx').getSimulation('sim')
144	I = ascpy.Integrator(M)
145	I.setEngine('IDA')
146	I.setReporter(ascpy.IntegratorReporterConsole(I))
147	I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11);
148	I.setMaxSubStep(0);
149	I.setInitialSubStep(0);
150	I.setMaxSubSteps(0);
151	I.setParameter('autodiff',True)
152	I.setParameter('linsolver','SPGMR')
153	I.setParameter('gsmodified',False)
154	I.analyse()
155	I.solve()
156	assert abs(float(M.sim.y1) - 5.1091e-08) < 1e-10;
157	assert abs(float(M.sim.y2) - 2.0437e-13) < 1e-15;
158	assert abs(float(M.sim.y3) - 1.0) < 1e-5;
159
160	def testIDAkryx(self):
161	self.L.load('johnpye/idakryx.a4c')
162	M = self.L.findType('idakryx').getSimulation('sim')
163	M.build()
164	I = ascpy.Integrator(M)
165	I.setEngine('IDA')
166	I.setReporter(ascpy.IntegratorReporterConsole(I))
167	I.setParameter('linsolver','SPGMR')
168	I.setParameter('gsmodified',False)
169	I.setParameter('autodiff',True)
170	I.setParameter('rtol',0)
171	I.setParameter('atol',1e-3);
172	I.setParameter('atolvect',False)
173	I.analyse()
174	I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 10);
175	print M.sim.udot[1][3];
176	I.solve()
177	assert 0
178
179	# move code above down here if you want to temporarily avoid testing it
180	class NotToBeTested:
181	def nothing(self):
182	pass
183
184	if __name__=='__main__':
185	unittest.main()