ascend/trunk/test.py

#!/usr/bin/env python
import unittest

import platform, sys
if platform.system() != "Windows":
    import dl
    sys.setdlopenflags(dl.RTLD_GLOBAL|dl.RTLD_NOW)

import ascpy
import math
import os, subprocess
import atexit
import cunit

class Ascend(unittest.TestCase):

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

class AscendSelfTester(Ascend):

    def _run(self,modelname,solvername="QRSlv",filename=None):
        if filename==None:
            filename = 'johnpye/%s.a4c' % modelname
        self.L.load(filename)
        T = self.L.findType(modelname)
        M = T.getSimulation('sim')
        M.build()
        M.solve(ascpy.Solver(solvername),ascpy.SolverReporter())    
        M.run(T.getMethod('self_test'))
        return M

class TestCompiler(Ascend):

    def testloading(self):
        pass

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

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

class TestSolver(AscendSelfTester):
    
    def testlog10(self):
        self._run('testlog10')

    def testconopt(self):
        self._run('testconopt',"CONOPT")                

    def testcmslv2(self):
        self._run('testcmslv2',"CMSlv") 

    def testsunpos1(self):
        self._run('example_1_6_1',"QRSlv","johnpye/sunpos.a4c")

    def testsunpos2(self):
        self._run('example_1_6_2',"QRSlv","johnpye/sunpos.a4c")

    def testsunpos3(self):
        self._run('example_1_7_1',"QRSlv","johnpye/sunpos.a4c")

    def testsunpos4(self):
        self._run('example_1_7_2',"QRSlv","johnpye/sunpos.a4c")

    def testsunpos5(self):
        self._run('example_1_7_3',"QRSlv","johnpye/sunpos.a4c")

    def testsunpos6(self):
        self._run('example_1_8_1',"QRSlv","johnpye/sunpos.a4c")

class TestIntegrator(Ascend):

    def testListIntegrators(self):
        I = ascpy.Integrator.getEngines()
        s1 = sorted([str(i) for i in I.values()])
        s2 = sorted(['IDA','LSODE','AWW'])
        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')
        M.setSolver(ascpy.Solver('QRSlv'))
        print M.getChildren()
        assert float(M.x) == 10.0
        assert float(M.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.x
        print "v = %f" % M.v
        assert abs(float(M.x) + 10) < 1e-2
        assert abs(float(M.v)) < 1e-2
        assert I.getNumObservedVars() == 3

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

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

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

    def testparameters(self):
        self.L.load('johnpye/shm.a4c')
        M = self.L.findType('shm').getSimulation('sim')
        M.build()
        I = ascpy.Integrator(M)
        I.setEngine('IDA')
        P = I.getParameters()
        for p in P:
            print p.getName(),"=",p.getValue()
        assert len(P)==11
        assert P[0].isStr()
        assert P[0].getName()=="linsolver"
        assert P[0].getValue()=='SPGMR'
        assert P[2].getName()=="autodiff"
        assert P[2].getValue()==True
        assert P[7].getName()=="atolvect"
        assert P[7].getBoolValue() == True
        P[2].setBoolValue(False)
        assert P[2].getBoolValue()==False
        I.setParameters(P)
        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')

class TestLSODE(Ascend):

    def testzill(self):
        self.L.load('johnpye/zill.a4c')
        T = self.L.findType('zill')
        M = T.getSimulation('sim')
        M.setSolver(ascpy.Solver('QRSlv'))
        I = ascpy.Integrator(M)
        I.setEngine('LSODE')
        I.setMinSubStep(1e-7)
        I.setMaxSubStep(0.001)
        I.setMaxSubSteps(10000)
        I.setReporter(ascpy.IntegratorReporterConsole(I))
        I.setLinearTimesteps(ascpy.Units(), 1.0, 1.5, 5)
        I.analyse()
        I.solve()
        M.run(T.getMethod('self_test'))

    def testnewton(self):
        sys.stderr.write("STARTING TESTNEWTON\n")
        self.L.load('johnpye/newton.a4c')
        T = self.L.findType('newton')
        M = T.getSimulation('sim')
        M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())   
        I = ascpy.Integrator(M)
        I.setEngine('LSODE')
        I.setParameter('rtolvect',False)
        I.setParameter('rtol',1e-7)
        I.setParameter('atolvect',False)
        I.setParameter('atol',1e-7)
        I.setMinSubStep(1e-7)
        I.setMaxSubStep(0.001)
        I.setMaxSubSteps(10000)
        
        I.setReporter(ascpy.IntegratorReporterConsole(I))
        I.setLinearTimesteps(ascpy.Units("s"), 0, 2*float(M.v)/float(M.g), 2)
        I.analyse()
        I.solve()
        print "At end of simulation,"
        print "x = %f" % M.x
        print "v = %f" % M.v
        M.run(T.getMethod('self_test'))

    def testlotka(self):
        self.L.load('johnpye/lotka.a4c')
        M = self.L.findType('lotka').getSimulation('sim')
        M.setSolver(ascpy.Solver("QRSlv"))
        I = ascpy.Integrator(M)
        I.setEngine('LSODE')
        I.setReporter(ascpy.IntegratorReporterConsole(I))
        I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 5)
        I.analyse()
        print "Number of vars = %d" % I.getNumVars()
        assert I.getNumVars()==2
        I.solve()
        assert I.getNumObservedVars() == 3;
        assert abs(M.R - 832) < 1.0
        assert abs(M.F - 21.36) < 0.1

#-------------------------------------------------------------------------------
# Testing of a external blackbox functions

class TestBlackBox(AscendSelfTester):
    def testparsefail0(self):
        try:
            self.L.load('test/blackbox/parsefail0.a4c')
            self.fail("parsefail0 should not have loaded without errors")
        except:
            pass

    def testparsefail1(self):
        try:
            self.L.load('test/blackbox/parsefail1.a4c')
            self.fail("parsefail1 should not have loaded without errors")
        except:
            pass

    def testparsefail2(self):
        try:
            self.L.load('test/blackbox/parsefail2.a4c')
            self.fail("parsefail2 should not have loaded without errors")
        except:
            pass

    def testparsefail3(self):
        try:
            self.L.load('test/blackbox/parsefail3.a4c')
            self.fail("parsefail3 should not have loaded without errors")
        except:
            pass

    def testparsefail4(self):
        try:
            self.L.load('test/blackbox/parsefail4.a4c')
            self.fail("parsefail4 should not have loaded")
        except:
            pass

    def testfail1(self):
        """Mismatched arg counts check-- tests bbox, not ascend."""
        self.L.load('test/blackbox/fail1.a4c')
        try:
            M = self.L.findType('fail1').getSimulation('sim')
            self.fail("expected exception was not raised")
        except RuntimeError,e:
            print "Caught exception '%s', assumed ok" % e

    def testfail2(self):
        """Incorrect data arg check -- tests bbox, not ascend"""
        self.L.load('test/blackbox/fail2.a4c')
        try:
            M = self.L.findType('fail2').getSimulation('sim')
            self.fail("expected exception was not raised")
        except RuntimeError,e:
            print "Caught exception '%s', assumed ok (should mention errors during instantiation)" % e

    def testpass1(self):
        """simple single bbox forward solve"""
        M = self._run('pass1',filename='test/blackbox/pass.a4c')

    def testpass2(self):
        """simple single bbox reverse solve"""
        M = self._run('pass2',filename='test/blackbox/pass.a4c')

    def testpass3(self):
        """simple double bbox solve"""
        M = self._run('pass3',filename='test/blackbox/pass3.a4c')

    def testpass4(self):
        """simple double bbox reverse solve"""
        M = self._run('pass4',filename='test/blackbox/pass3.a4c')

    def testpass5(self):
        M = self._run('pass5',filename='test/blackbox/pass5.a4c')

    def testpass6(self):
        M = self._run('pass6',filename='test/blackbox/pass5.a4c')

    def testpass7(self):
        M = self._run('pass7',filename='test/blackbox/passmerge.a4c')

    def testpass8(self):
        M = self._run('pass8',filename='test/blackbox/passmerge.a4c')

    def testpass9(self):
        M = self._run('pass9',filename='test/blackbox/passmerge.a4c')

    def testpass10(self):
        M = self._run('pass10',filename='test/blackbox/passmerge.a4c')

    def testpass11(self):
        M = self._run('pass11',filename='test/blackbox/passmerge.a4c')

    def testpass12(self):
        M = self._run('pass12',filename='test/blackbox/passmerge.a4c')

    def testpass13(self):
        """cross-merged input/output solve"""
        M = self._run('pass13',filename='test/blackbox/passmerge.a4c')

    def testpass14(self):
        """cross-merged input/output reverse solve"""
        M = self._run('pass14',filename='test/blackbox/passmerge.a4c')

    def testpass20(self):
        M = self._run('pass20',filename='test/blackbox/passarray.a4c')

    def testparsefail21(self):
        """dense array of black boxes wrong syntax"""
        try:
            self.L.load('test/blackbox/parsefail21.a4c')
            self.fail("parsefail21 should not have loaded without errors")
        except:
            pass

    def testpass22(self):
        M = self._run('pass22',filename='test/blackbox/passarray.a4c')

    def testpass23(self):
        M = self._run('pass23',filename='test/blackbox/passarray.a4c')

    def testpass61(self):
        M = self._run('pass61',filename='test/blackbox/reinstantiate.a4c')

    def testpass62(self):
        M = self._run('pass62',filename='test/blackbox/reinstantiate.a4c')

    def testpass64(self):
        M = self._run('pass64',filename='test/blackbox/reinstantiate.a4c')

    def testpass65(self):
        M = self._run('pass65',filename='test/blackbox/reinstantiate.a4c')

    def testpass66(self):
        M = self._run('pass66',filename='test/blackbox/reinstantiate.a4c')

    def testpass67(self):
        M = self._run('pass67',filename='test/blackbox/reinstantiate.a4c')

class TestExtFn(AscendSelfTester):
    def testextfntest(self):
        M = self._run('extfntest',filename='johnpye/extfn/extfntest.a4c')
        self.assertAlmostEqual(M.y, 2);
        self.assertAlmostEqual(M.x, 1);
        self.assertAlmostEqual(M.y, M.x + 1);

#   THIS TEST FAILS
#   def testextrelfor(self):
#       self.L.load('johnpye/extfn/extrelfor.a4c')
#       T = self.L.findType('extrelfor')
#       M = T.getSimulation('sim')
#       M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
#       print "x[1] = %f" % M.x[1]
#       print "x[2] = %f" % M.x[2]
#       print "x[3] = %f" % M.x[3]
#       M.run(T.getMethod('self_test'))

    def testextrelrepeat(self):
        M = self._run('extrelrepeat',filename='johnpye/extfn/extrelrepeat.a4c')

#-------------------------------------------------------------------------------
# Testing of a ExtPy - external python methods

class TestExtPy(AscendSelfTester):
    def testextpytest(self):
        print "-------------------=--=-=-=-"
        M = self._run('extpytest',filename='johnpye/extpy/extpytest.a4c')

#-------------------------------------------------------------------------------
# Testing of freesteam external steam properties functions

with_freesteam = True
try:
    import freesteam
    have_freesteam = True
except ImportError,e:
    have_freesteam = False

if with_freesteam and have_freesteam:
    class TestFreesteam(Ascend):
        def testload(self):
            self.L.load('johnpye/thermalequilibrium2.a4c')

        def testinstantiate(self):
            self.testload()
            M = self.L.findType('thermalequilibrium2').getSimulation('sim')

        def testsolve(self):
            self.testinstantiate()
            M.setSolver(ascpy.Solver("QRSlv"))
            #I = ascpy.Integrator(M)
            #I.setEngine('LSODE')
            #I.setReporter(ascpy.IntegratorReporterConsole(I))
            #I.setLinearTimesteps(ascpy.Units("s"), 0, 3000, 30)
            #I.setMinSubStep(0.01)
            #I.setInitialSubStep(0.1)
            #I.analyse()
            #print "Number of vars = %d" % I.getNumVars()
            #assert I.getNumVars()==2
            #I.solve()
            #assert I.getNumObservedVars() == 3;
            #assert abs(M.R - 832) < 1.0
            #assert abs(M.F - 21.36) < 0.1


#-------------------------------------------------------------------------------
# Testing of IDA models using DENSE linear solver

class TestIDADENSE(Ascend):
    """IDA DAE integrator, DENSE linear solver"""

    def testnewton(self):
        sys.stderr.write("STARTING TESTNEWTON\n")
        self.L.load('johnpye/newton.a4c')
        T = self.L.findType('newton')
        M = T.getSimulation('sim')
        M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())   
        I = ascpy.Integrator(M)
        I.setEngine('IDA')
        I.setParameter('linsolver','DENSE')
        I.setParameter('safeeval',True)
        I.setParameter('rtol',1e-8)
        I.setMaxSubStep(0.001)
        I.setMaxSubSteps(10000)
        
        I.setReporter(ascpy.IntegratorReporterConsole(I))
        I.setLinearTimesteps(ascpy.Units("s"), 0, 2*float(M.v)/float(M.g), 2)
        I.analyse()
        I.solve()
        print "At end of simulation,"
        print "x = %f" % M.x
        print "v = %f" % M.v
        M.run(T.getMethod('self_test'))

    def testlotkaDENSE(self):
        self.L.load('johnpye/lotka.a4c')
        M = self.L.findType('lotka').getSimulation('sim')
        M.setSolver(ascpy.Solver("QRSlv"))
        I = ascpy.Integrator(M)
        I.setEngine('IDA')
        I.setReporter(ascpy.IntegratorReporterConsole(I))
        I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 5);
        I.setParameter('linsolver','DENSE')
        I.setParameter('rtol',1e-8);
        I.analyse()
        assert I.getNumVars()==2
        assert abs(M.R - 1000) < 1e-300
        I.solve()
        assert I.getNumObservedVars() == 3
        assert abs(M.R - 832) < 1.0
        assert abs(M.F - 21.36) < 0.1
        
    def testdenx(self):
        print "-----------------------------====="
        self.L.load('johnpye/idadenx.a4c')
        M = self.L.findType('idadenx').getSimulation('sim')
        M.setSolver(ascpy.Solver("QRSlv"))
        I = ascpy.Integrator(M)
        I.setEngine('IDA')
        I.setParameter('calcic','YA_YPD')
        I.setParameter('linsolver','DENSE')
        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.analyse()
        I.solve()
        assert abs(float(M.y1) - 5.1091e-08) < 2e-9
        assert abs(float(M.y2) - 2.0437e-13) < 2e-14
        assert abs(float(M.y3) - 1.0) < 1e-5

    def testkryxDENSE(self):
        self.L.load('johnpye/idakryx.a4c')
        M = self.L.findType('idakryx').getSimulation('sim')
        M.setSolver(ascpy.Solver('QRSlv'))
        M.build()
        I = ascpy.Integrator(M)
        I.setEngine('IDA')
        I.setReporter(ascpy.IntegratorReporterConsole(I))
        I.setParameter('linsolver','DENSE')
        I.setParameter('maxl',8)
        I.setParameter('gsmodified',False)
        I.setParameter('autodiff',True)
        I.setParameter('rtol',0)
        I.setParameter('atol',1e-3);
        I.setParameter('atolvect',False)
        I.setParameter('calcic','YA_YDP')
        I.analyse()
        I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 11)
        I.solve()
        assert abs(M.u[2][2].getValue()) < 1e-5
    
#-------------------------------------------------------------------------------
# Testing of IDA models using SPGMR linear solver (Krylov)
    
# these tests are disabled until SPGMR preconditioning has been implemented
class TestIDASPGMR:#(Ascend):
    def testlotka(self):
        self.L.load('johnpye/lotka.a4c')
        M = self.L.findType('lotka').getSimulation('sim')
        M.setSolver(ascpy.Solver("QRSlv"))
        I = ascpy.Integrator(M)
        I.setEngine('IDA')
        I.setReporter(ascpy.IntegratorReporterConsole(I))
        I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 5)
        I.setParameter('rtol',1e-8)
        I.analyse()
        assert I.getNumVars()==2
        assert abs(M.R - 1000) < 1e-300
        I.solve()
        assert I.getNumObservedVars() == 3
        assert abs(M.R - 832) < 1.0
        assert abs(M.F - 21.36) < 0.1


    def testkryx(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('prec','JACOBI')
        I.setParameter('maxl',8)
        I.setParameter('gsmodified',False)
        I.setParameter('autodiff',True)
        I.setParameter('gsmodified',True)
        I.setParameter('rtol',0)
        I.setParameter('atol',1e-3);
        I.setParameter('atolvect',False)
        I.setParameter('calcic','Y')
        I.analyse()
        I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 10);
        print M.udot[1][3]
        I.solve()
        assert 0

    def testzill(self):
        self.L.load('johnpye/zill.a4c')
        T = self.L.findType('zill')
        M = T.getSimulation('sim')
        M.setSolver(ascpy.Solver('QRSlv'))
        I = ascpy.Integrator(M)
        I.setEngine('IDA')
        I.setParameter('safeeval',False)
        I.setMinSubStep(1e-7)
        I.setMaxSubStep(0.001)
        I.setMaxSubSteps(10000)
        I.setReporter(ascpy.IntegratorReporterConsole(I))
        I.setLinearTimesteps(ascpy.Units(), 1.0, 1.5, 5)
        I.analyse()
        I.solve()
        M.run(T.getMethod('self_test'))

    def testdenxSPGMR(self):
        self.L.load('johnpye/idadenx.a4c')
        M = self.L.findType('idadenx').getSimulation('sim')
        M.setSolver(ascpy.Solver('QRSlv'))
        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.setParameter('maxncf',10)
        I.analyse()
        I.solve()
        assert abs(float(M.y1) - 5.1091e-08) < 1e-10
        assert abs(float(M.y2) - 2.0437e-13) < 1e-15
        assert abs(float(M.y3) - 1.0) < 1e-5

# move code above down here if you want to temporarily avoid testing it
class NotToBeTested:
    def nothing(self):
        pass

if __name__=='__main__':
    atexit.register(ascpy.shutdown)
    #suite = unittest.TestSuite()
    #suite = unittest.defaultTestLoader.loadTestsFromName('__main__')
    #unittest.TextTestRunner(verbosity=2).run(suite)
    unittest.main() 
1	#!/usr/bin/env python
2	import unittest
3
4	import platform, sys
5	if platform.system() != "Windows":
6	import dl
7	sys.setdlopenflags(dl.RTLD_GLOBAL\|dl.RTLD_NOW)
8
9	import ascpy
10	import math
11	import os, subprocess
12	import atexit
13	import cunit
14
15	class Ascend(unittest.TestCase):
16
17	def setUp(self):
18	import ascpy
19	self.L = ascpy.Library()
20
21	def tearDown(self):
22	self.L.clear()
23	del self.L
24
25	class AscendSelfTester(Ascend):
26
27	def _run(self,modelname,solvername="QRSlv",filename=None):
28	if filename==None:
29	filename = 'johnpye/%s.a4c' % modelname
30	self.L.load(filename)
31	T = self.L.findType(modelname)
32	M = T.getSimulation('sim')
33	M.build()
34	M.solve(ascpy.Solver(solvername),ascpy.SolverReporter())
35	M.run(T.getMethod('self_test'))
36	return M
37
38	class TestCompiler(Ascend):
39
40	def testloading(self):
41	pass
42
43	def testsystema4l(self):
44	self.L.load('system.a4l')
45
46	def testatomsa4l(self):
47	self.L.load('atoms.a4l')
48
49	class TestSolver(AscendSelfTester):
50
51	def testlog10(self):
52	self._run('testlog10')
53
54	def testconopt(self):
55	self._run('testconopt',"CONOPT")
56
57	def testcmslv2(self):
58	self._run('testcmslv2',"CMSlv")
59
60	def testsunpos1(self):
61	self._run('example_1_6_1',"QRSlv","johnpye/sunpos.a4c")
62
63	def testsunpos2(self):
64	self._run('example_1_6_2',"QRSlv","johnpye/sunpos.a4c")
65
66	def testsunpos3(self):
67	self._run('example_1_7_1',"QRSlv","johnpye/sunpos.a4c")
68
69	def testsunpos4(self):
70	self._run('example_1_7_2',"QRSlv","johnpye/sunpos.a4c")
71
72	def testsunpos5(self):
73	self._run('example_1_7_3',"QRSlv","johnpye/sunpos.a4c")
74
75	def testsunpos6(self):
76	self._run('example_1_8_1',"QRSlv","johnpye/sunpos.a4c")
77
78	class TestIntegrator(Ascend):
79
80	def testListIntegrators(self):
81	I = ascpy.Integrator.getEngines()
82	s1 = sorted([str(i) for i in I.values()])
83	s2 = sorted(['IDA','LSODE','AWW'])
84	assert s1==s2
85
86	# this routine is reused by both testIDA and testLSODE
87	def _testIntegrator(self,integratorname):
88	self.L.load('johnpye/shm.a4c')
89	M = self.L.findType('shm').getSimulation('sim')
90	M.setSolver(ascpy.Solver('QRSlv'))
91	print M.getChildren()
92	assert float(M.x) == 10.0
93	assert float(M.v) == 0.0
94	t_end = math.pi
95
96	I = ascpy.Integrator(M)
97	I.setReporter(ascpy.IntegratorReporterNull(I))
98	I.setEngine(integratorname);
99	I.setLinearTimesteps(ascpy.Units("s"), 0.0, t_end, 100);
100	I.setMinSubStep(0.0005); # these limits are required by IDA at present (numeric diff)
101	I.setMaxSubStep(0.02);
102	I.setInitialSubStep(0.001);
103	I.setMaxSubSteps(200);
104	if(integratorname=='IDA'):
105	I.setParameter('autodiff',False)
106	I.analyse();
107	I.solve();
108	print "At end of simulation,"
109	print "x = %f" % M.x
110	print "v = %f" % M.v
111	assert abs(float(M.x) + 10) < 1e-2
112	assert abs(float(M.v)) < 1e-2
113	assert I.getNumObservedVars() == 3
114
115	def testInvalidIntegrator(self):
116	self.L.load('johnpye/shm.a4c')
117	M = self.L.findType('shm').getSimulation('sim')
118	M.setSolver(ascpy.Solver('QRSlv'))
119	I = ascpy.Integrator(M)
120	try:
121	I.setEngine('___NONEXISTENT____')
122	except RuntimeError:
123	return
124	self.fail("setEngine did not raise error!")
125
126	def testLSODE(self):
127	self._testIntegrator('LSODE')
128
129	def testIDA(self):
130	self._testIntegrator('IDA')
131
132	def testparameters(self):
133	self.L.load('johnpye/shm.a4c')
134	M = self.L.findType('shm').getSimulation('sim')
135	M.build()
136	I = ascpy.Integrator(M)
137	I.setEngine('IDA')
138	P = I.getParameters()
139	for p in P:
140	print p.getName(),"=",p.getValue()
141	assert len(P)==11
142	assert P[0].isStr()
143	assert P[0].getName()=="linsolver"
144	assert P[0].getValue()=='SPGMR'
145	assert P[2].getName()=="autodiff"
146	assert P[2].getValue()==True
147	assert P[7].getName()=="atolvect"
148	assert P[7].getBoolValue() == True
149	P[2].setBoolValue(False)
150	assert P[2].getBoolValue()==False
151	I.setParameters(P)
152	assert I.getParameterValue('autodiff')==False
153	I.setParameter('autodiff',True)
154	try:
155	v = I.getParameterValue('nonexist')
156	except KeyError:
157	pass
158	else:
159	self.fail('Failed to trip invalid Integrator parameter')
160
161	class TestLSODE(Ascend):
162
163	def testzill(self):
164	self.L.load('johnpye/zill.a4c')
165	T = self.L.findType('zill')
166	M = T.getSimulation('sim')
167	M.setSolver(ascpy.Solver('QRSlv'))
168	I = ascpy.Integrator(M)
169	I.setEngine('LSODE')
170	I.setMinSubStep(1e-7)
171	I.setMaxSubStep(0.001)
172	I.setMaxSubSteps(10000)
173	I.setReporter(ascpy.IntegratorReporterConsole(I))
174	I.setLinearTimesteps(ascpy.Units(), 1.0, 1.5, 5)
175	I.analyse()
176	I.solve()
177	M.run(T.getMethod('self_test'))
178
179	def testnewton(self):
180	sys.stderr.write("STARTING TESTNEWTON\n")
181	self.L.load('johnpye/newton.a4c')
182	T = self.L.findType('newton')
183	M = T.getSimulation('sim')
184	M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())
185	I = ascpy.Integrator(M)
186	I.setEngine('LSODE')
187	I.setParameter('rtolvect',False)
188	I.setParameter('rtol',1e-7)
189	I.setParameter('atolvect',False)
190	I.setParameter('atol',1e-7)
191	I.setMinSubStep(1e-7)
192	I.setMaxSubStep(0.001)
193	I.setMaxSubSteps(10000)
194
195	I.setReporter(ascpy.IntegratorReporterConsole(I))
196	I.setLinearTimesteps(ascpy.Units("s"), 0, 2*float(M.v)/float(M.g), 2)
197	I.analyse()
198	I.solve()
199	print "At end of simulation,"
200	print "x = %f" % M.x
201	print "v = %f" % M.v
202	M.run(T.getMethod('self_test'))
203
204	def testlotka(self):
205	self.L.load('johnpye/lotka.a4c')
206	M = self.L.findType('lotka').getSimulation('sim')
207	M.setSolver(ascpy.Solver("QRSlv"))
208	I = ascpy.Integrator(M)
209	I.setEngine('LSODE')
210	I.setReporter(ascpy.IntegratorReporterConsole(I))
211	I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 5)
212	I.analyse()
213	print "Number of vars = %d" % I.getNumVars()
214	assert I.getNumVars()==2
215	I.solve()
216	assert I.getNumObservedVars() == 3;
217	assert abs(M.R - 832) < 1.0
218	assert abs(M.F - 21.36) < 0.1
219
220	#-------------------------------------------------------------------------------
221	# Testing of a external blackbox functions
222
223	class TestBlackBox(AscendSelfTester):
224	def testparsefail0(self):
225	try:
226	self.L.load('test/blackbox/parsefail0.a4c')
227	self.fail("parsefail0 should not have loaded without errors")
228	except:
229	pass
230
231	def testparsefail1(self):
232	try:
233	self.L.load('test/blackbox/parsefail1.a4c')
234	self.fail("parsefail1 should not have loaded without errors")
235	except:
236	pass
237
238	def testparsefail2(self):
239	try:
240	self.L.load('test/blackbox/parsefail2.a4c')
241	self.fail("parsefail2 should not have loaded without errors")
242	except:
243	pass
244
245	def testparsefail3(self):
246	try:
247	self.L.load('test/blackbox/parsefail3.a4c')
248	self.fail("parsefail3 should not have loaded without errors")
249	except:
250	pass
251
252	def testparsefail4(self):
253	try:
254	self.L.load('test/blackbox/parsefail4.a4c')
255	self.fail("parsefail4 should not have loaded")
256	except:
257	pass
258
259	def testfail1(self):
260	"""Mismatched arg counts check-- tests bbox, not ascend."""
261	self.L.load('test/blackbox/fail1.a4c')
262	try:
263	M = self.L.findType('fail1').getSimulation('sim')
264	self.fail("expected exception was not raised")
265	except RuntimeError,e:
266	print "Caught exception '%s', assumed ok" % e
267
268	def testfail2(self):
269	"""Incorrect data arg check -- tests bbox, not ascend"""
270	self.L.load('test/blackbox/fail2.a4c')
271	try:
272	M = self.L.findType('fail2').getSimulation('sim')
273	self.fail("expected exception was not raised")
274	except RuntimeError,e:
275	print "Caught exception '%s', assumed ok (should mention errors during instantiation)" % e
276
277	def testpass1(self):
278	"""simple single bbox forward solve"""
279	M = self._run('pass1',filename='test/blackbox/pass.a4c')
280
281	def testpass2(self):
282	"""simple single bbox reverse solve"""
283	M = self._run('pass2',filename='test/blackbox/pass.a4c')
284
285	def testpass3(self):
286	"""simple double bbox solve"""
287	M = self._run('pass3',filename='test/blackbox/pass3.a4c')
288
289	def testpass4(self):
290	"""simple double bbox reverse solve"""
291	M = self._run('pass4',filename='test/blackbox/pass3.a4c')
292
293	def testpass5(self):
294	M = self._run('pass5',filename='test/blackbox/pass5.a4c')
295
296	def testpass6(self):
297	M = self._run('pass6',filename='test/blackbox/pass5.a4c')
298
299	def testpass7(self):
300	M = self._run('pass7',filename='test/blackbox/passmerge.a4c')
301
302	def testpass8(self):
303	M = self._run('pass8',filename='test/blackbox/passmerge.a4c')
304
305	def testpass9(self):
306	M = self._run('pass9',filename='test/blackbox/passmerge.a4c')
307
308	def testpass10(self):
309	M = self._run('pass10',filename='test/blackbox/passmerge.a4c')
310
311	def testpass11(self):
312	M = self._run('pass11',filename='test/blackbox/passmerge.a4c')
313
314	def testpass12(self):
315	M = self._run('pass12',filename='test/blackbox/passmerge.a4c')
316
317	def testpass13(self):
318	"""cross-merged input/output solve"""
319	M = self._run('pass13',filename='test/blackbox/passmerge.a4c')
320
321	def testpass14(self):
322	"""cross-merged input/output reverse solve"""
323	M = self._run('pass14',filename='test/blackbox/passmerge.a4c')
324
325	def testpass20(self):
326	M = self._run('pass20',filename='test/blackbox/passarray.a4c')
327
328	def testparsefail21(self):
329	"""dense array of black boxes wrong syntax"""
330	try:
331	self.L.load('test/blackbox/parsefail21.a4c')
332	self.fail("parsefail21 should not have loaded without errors")
333	except:
334	pass
335
336	def testpass22(self):
337	M = self._run('pass22',filename='test/blackbox/passarray.a4c')
338
339	def testpass23(self):
340	M = self._run('pass23',filename='test/blackbox/passarray.a4c')
341
342	def testpass61(self):
343	M = self._run('pass61',filename='test/blackbox/reinstantiate.a4c')
344
345	def testpass62(self):
346	M = self._run('pass62',filename='test/blackbox/reinstantiate.a4c')
347
348	def testpass64(self):
349	M = self._run('pass64',filename='test/blackbox/reinstantiate.a4c')
350
351	def testpass65(self):
352	M = self._run('pass65',filename='test/blackbox/reinstantiate.a4c')
353
354	def testpass66(self):
355	M = self._run('pass66',filename='test/blackbox/reinstantiate.a4c')
356
357	def testpass67(self):
358	M = self._run('pass67',filename='test/blackbox/reinstantiate.a4c')
359
360	class TestExtFn(AscendSelfTester):
361	def testextfntest(self):
362	M = self._run('extfntest',filename='johnpye/extfn/extfntest.a4c')
363	self.assertAlmostEqual(M.y, 2);
364	self.assertAlmostEqual(M.x, 1);
365	self.assertAlmostEqual(M.y, M.x + 1);
366
367	# THIS TEST FAILS
368	# def testextrelfor(self):
369	# self.L.load('johnpye/extfn/extrelfor.a4c')
370	# T = self.L.findType('extrelfor')
371	# M = T.getSimulation('sim')
372	# M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
373	# print "x[1] = %f" % M.x[1]
374	# print "x[2] = %f" % M.x[2]
375	# print "x[3] = %f" % M.x[3]
376	# M.run(T.getMethod('self_test'))
377
378	def testextrelrepeat(self):
379	M = self._run('extrelrepeat',filename='johnpye/extfn/extrelrepeat.a4c')
380
381	#-------------------------------------------------------------------------------
382	# Testing of a ExtPy - external python methods
383
384	class TestExtPy(AscendSelfTester):
385	def testextpytest(self):
386	print "-------------------=--=-=-=-"
387	M = self._run('extpytest',filename='johnpye/extpy/extpytest.a4c')
388
389	#-------------------------------------------------------------------------------
390	# Testing of freesteam external steam properties functions
391
392	with_freesteam = True
393	try:
394	import freesteam
395	have_freesteam = True
396	except ImportError,e:
397	have_freesteam = False
398
399	if with_freesteam and have_freesteam:
400	class TestFreesteam(Ascend):
401	def testload(self):
402	self.L.load('johnpye/thermalequilibrium2.a4c')
403
404	def testinstantiate(self):
405	self.testload()
406	M = self.L.findType('thermalequilibrium2').getSimulation('sim')
407
408	def testsolve(self):
409	self.testinstantiate()
410	M.setSolver(ascpy.Solver("QRSlv"))
411	#I = ascpy.Integrator(M)
412	#I.setEngine('LSODE')
413	#I.setReporter(ascpy.IntegratorReporterConsole(I))
414	#I.setLinearTimesteps(ascpy.Units("s"), 0, 3000, 30)
415	#I.setMinSubStep(0.01)
416	#I.setInitialSubStep(0.1)
417	#I.analyse()
418	#print "Number of vars = %d" % I.getNumVars()
419	#assert I.getNumVars()==2
420	#I.solve()
421	#assert I.getNumObservedVars() == 3;
422	#assert abs(M.R - 832) < 1.0
423	#assert abs(M.F - 21.36) < 0.1
424
425
426	#-------------------------------------------------------------------------------
427	# Testing of IDA models using DENSE linear solver
428
429	class TestIDADENSE(Ascend):
430	"""IDA DAE integrator, DENSE linear solver"""
431
432	def testnewton(self):
433	sys.stderr.write("STARTING TESTNEWTON\n")
434	self.L.load('johnpye/newton.a4c')
435	T = self.L.findType('newton')
436	M = T.getSimulation('sim')
437	M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())
438	I = ascpy.Integrator(M)
439	I.setEngine('IDA')
440	I.setParameter('linsolver','DENSE')
441	I.setParameter('safeeval',True)
442	I.setParameter('rtol',1e-8)
443	I.setMaxSubStep(0.001)
444	I.setMaxSubSteps(10000)
445
446	I.setReporter(ascpy.IntegratorReporterConsole(I))
447	I.setLinearTimesteps(ascpy.Units("s"), 0, 2*float(M.v)/float(M.g), 2)
448	I.analyse()
449	I.solve()
450	print "At end of simulation,"
451	print "x = %f" % M.x
452	print "v = %f" % M.v
453	M.run(T.getMethod('self_test'))
454
455	def testlotkaDENSE(self):
456	self.L.load('johnpye/lotka.a4c')
457	M = self.L.findType('lotka').getSimulation('sim')
458	M.setSolver(ascpy.Solver("QRSlv"))
459	I = ascpy.Integrator(M)
460	I.setEngine('IDA')
461	I.setReporter(ascpy.IntegratorReporterConsole(I))
462	I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 5);
463	I.setParameter('linsolver','DENSE')
464	I.setParameter('rtol',1e-8);
465	I.analyse()
466	assert I.getNumVars()==2
467	assert abs(M.R - 1000) < 1e-300
468	I.solve()
469	assert I.getNumObservedVars() == 3
470	assert abs(M.R - 832) < 1.0
471	assert abs(M.F - 21.36) < 0.1
472
473	def testdenx(self):
474	print "-----------------------------====="
475	self.L.load('johnpye/idadenx.a4c')
476	M = self.L.findType('idadenx').getSimulation('sim')
477	M.setSolver(ascpy.Solver("QRSlv"))
478	I = ascpy.Integrator(M)
479	I.setEngine('IDA')
480	I.setParameter('calcic','YA_YPD')
481	I.setParameter('linsolver','DENSE')
482	I.setReporter(ascpy.IntegratorReporterConsole(I))
483	I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11)
484	I.setMaxSubStep(0);
485	I.setInitialSubStep(0)
486	I.setMaxSubSteps(0);
487	I.setParameter('autodiff',True)
488	I.analyse()
489	I.solve()
490	assert abs(float(M.y1) - 5.1091e-08) < 2e-9
491	assert abs(float(M.y2) - 2.0437e-13) < 2e-14
492	assert abs(float(M.y3) - 1.0) < 1e-5
493
494	def testkryxDENSE(self):
495	self.L.load('johnpye/idakryx.a4c')
496	M = self.L.findType('idakryx').getSimulation('sim')
497	M.setSolver(ascpy.Solver('QRSlv'))
498	M.build()
499	I = ascpy.Integrator(M)
500	I.setEngine('IDA')
501	I.setReporter(ascpy.IntegratorReporterConsole(I))
502	I.setParameter('linsolver','DENSE')
503	I.setParameter('maxl',8)
504	I.setParameter('gsmodified',False)
505	I.setParameter('autodiff',True)
506	I.setParameter('rtol',0)
507	I.setParameter('atol',1e-3);
508	I.setParameter('atolvect',False)
509	I.setParameter('calcic','YA_YDP')
510	I.analyse()
511	I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 11)
512	I.solve()
513	assert abs(M.u[2][2].getValue()) < 1e-5
514
515	#-------------------------------------------------------------------------------
516	# Testing of IDA models using SPGMR linear solver (Krylov)
517
518	# these tests are disabled until SPGMR preconditioning has been implemented
519	class TestIDASPGMR:#(Ascend):
520	def testlotka(self):
521	self.L.load('johnpye/lotka.a4c')
522	M = self.L.findType('lotka').getSimulation('sim')
523	M.setSolver(ascpy.Solver("QRSlv"))
524	I = ascpy.Integrator(M)
525	I.setEngine('IDA')
526	I.setReporter(ascpy.IntegratorReporterConsole(I))
527	I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 5)
528	I.setParameter('rtol',1e-8)
529	I.analyse()
530	assert I.getNumVars()==2
531	assert abs(M.R - 1000) < 1e-300
532	I.solve()
533	assert I.getNumObservedVars() == 3
534	assert abs(M.R - 832) < 1.0
535	assert abs(M.F - 21.36) < 0.1
536
537
538	def testkryx(self):
539	self.L.load('johnpye/idakryx.a4c')
540	M = self.L.findType('idakryx').getSimulation('sim')
541	M.build()
542	I = ascpy.Integrator(M)
543	I.setEngine('IDA')
544	I.setReporter(ascpy.IntegratorReporterConsole(I))
545	I.setParameter('linsolver','SPGMR')
546	I.setParameter('prec','JACOBI')
547	I.setParameter('maxl',8)
548	I.setParameter('gsmodified',False)
549	I.setParameter('autodiff',True)
550	I.setParameter('gsmodified',True)
551	I.setParameter('rtol',0)
552	I.setParameter('atol',1e-3);
553	I.setParameter('atolvect',False)
554	I.setParameter('calcic','Y')
555	I.analyse()
556	I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 10);
557	print M.udot[1][3]
558	I.solve()
559	assert 0
560
561	def testzill(self):
562	self.L.load('johnpye/zill.a4c')
563	T = self.L.findType('zill')
564	M = T.getSimulation('sim')
565	M.setSolver(ascpy.Solver('QRSlv'))
566	I = ascpy.Integrator(M)
567	I.setEngine('IDA')
568	I.setParameter('safeeval',False)
569	I.setMinSubStep(1e-7)
570	I.setMaxSubStep(0.001)
571	I.setMaxSubSteps(10000)
572	I.setReporter(ascpy.IntegratorReporterConsole(I))
573	I.setLinearTimesteps(ascpy.Units(), 1.0, 1.5, 5)
574	I.analyse()
575	I.solve()
576	M.run(T.getMethod('self_test'))
577
578	def testdenxSPGMR(self):
579	self.L.load('johnpye/idadenx.a4c')
580	M = self.L.findType('idadenx').getSimulation('sim')
581	M.setSolver(ascpy.Solver('QRSlv'))
582	I = ascpy.Integrator(M)
583	I.setEngine('IDA')
584	I.setReporter(ascpy.IntegratorReporterConsole(I))
585	I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11)
586	I.setMaxSubStep(0);
587	I.setInitialSubStep(0);
588	I.setMaxSubSteps(0);
589	I.setParameter('autodiff',True)
590	I.setParameter('linsolver','SPGMR')
591	I.setParameter('gsmodified',False)
592	I.setParameter('maxncf',10)
593	I.analyse()
594	I.solve()
595	assert abs(float(M.y1) - 5.1091e-08) < 1e-10
596	assert abs(float(M.y2) - 2.0437e-13) < 1e-15
597	assert abs(float(M.y3) - 1.0) < 1e-5
598
599	# move code above down here if you want to temporarily avoid testing it
600	class NotToBeTested:
601	def nothing(self):
602	pass
603
604	if __name__=='__main__':
605	atexit.register(ascpy.shutdown)
606	#suite = unittest.TestSuite()
607	#suite = unittest.defaultTestLoader.loadTestsFromName('__main__')
608	#unittest.TextTestRunner(verbosity=2).run(suite)
609	unittest.main()