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')
        M = self.L.findType('fail1').getSimulation('sim')
        try:
            M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())
            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')
        M = self.L.findType('fail2').getSimulation('sim')
        M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())

    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	johnpye	1008	#!/usr/bin/env python
2	johnpye	669	import unittest
3	johnpye	1028
4			import platform, sys
5			if platform.system() != "Windows":
6			import dl
7			sys.setdlopenflags(dl.RTLD_GLOBAL\|dl.RTLD_NOW)
8
9	johnpye	938	import ascpy
10	johnpye	940	import math
11	johnpye	1028	import os, subprocess
12	johnpye	966	import atexit
13	johnpye	998	import cunit
14	johnpye	669
15	johnpye	956	class Ascend(unittest.TestCase):
16	johnpye	669
17	johnpye	933	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	johnpye	1024	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	johnpye	966	class TestCompiler(Ascend):
39
40	johnpye	941	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	johnpye	1024	class TestSolver(AscendSelfTester):
50	johnpye	966
51			def testlog10(self):
52			self._run('testlog10')
53
54			def testconopt(self):
55			self._run('testconopt',"CONOPT")
56
57			def testcmslv2(self):
58	johnpye	974	self._run('testcmslv2',"CMSlv")
59	johnpye	966
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	johnpye	941	def testListIntegrators(self):
81			I = ascpy.Integrator.getEngines()
82			s1 = sorted([str(i) for i in I.values()])
83	johnpye	972	s2 = sorted(['IDA','LSODE','AWW'])
84	johnpye	941	assert s1==s2
85
86	johnpye	942	# this routine is reused by both testIDA and testLSODE
87	johnpye	941	def _testIntegrator(self,integratorname):
88	johnpye	940	self.L.load('johnpye/shm.a4c')
89			M = self.L.findType('shm').getSimulation('sim')
90	johnpye	972	M.setSolver(ascpy.Solver('QRSlv'))
91	johnpye	979	print M.getChildren()
92			assert float(M.x) == 10.0
93			assert float(M.v) == 0.0
94	johnpye	941	t_end = math.pi
95	johnpye	940
96			I = ascpy.Integrator(M)
97			I.setReporter(ascpy.IntegratorReporterNull(I))
98	johnpye	941	I.setEngine(integratorname);
99	johnpye	940	I.setLinearTimesteps(ascpy.Units("s"), 0.0, t_end, 100);
100	johnpye	941	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	johnpye	944	if(integratorname=='IDA'):
105			I.setParameter('autodiff',False)
106	johnpye	940	I.analyse();
107			I.solve();
108	johnpye	941	print "At end of simulation,"
109	johnpye	979	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	johnpye	940	assert I.getNumObservedVars() == 3
114
115	johnpye	941	def testInvalidIntegrator(self):
116	johnpye	966	self.L.load('johnpye/shm.a4c')
117	johnpye	941	M = self.L.findType('shm').getSimulation('sim')
118	johnpye	972	M.setSolver(ascpy.Solver('QRSlv'))
119	johnpye	941	I = ascpy.Integrator(M)
120			try:
121			I.setEngine('___NONEXISTENT____')
122	johnpye	972	except RuntimeError:
123	johnpye	941	return
124			self.fail("setEngine did not raise error!")
125
126			def testLSODE(self):
127			self._testIntegrator('LSODE')
128
129	johnpye	972	def testIDA(self):
130			self._testIntegrator('IDA')
131
132	johnpye	1016	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	johnpye	972	class TestLSODE(Ascend):
162
163	johnpye	964	def testzill(self):
164			self.L.load('johnpye/zill.a4c')
165			T = self.L.findType('zill')
166			M = T.getSimulation('sim')
167	johnpye	972	M.setSolver(ascpy.Solver('QRSlv'))
168	johnpye	964	I = ascpy.Integrator(M)
169	johnpye	966	I.setEngine('LSODE')
170			I.setMinSubStep(1e-7)
171			I.setMaxSubStep(0.001)
172			I.setMaxSubSteps(10000)
173	johnpye	964	I.setReporter(ascpy.IntegratorReporterConsole(I))
174	johnpye	1017	I.setLinearTimesteps(ascpy.Units(), 1.0, 1.5, 5)
175	johnpye	964	I.analyse()
176			I.solve()
177			M.run(T.getMethod('self_test'))
178
179	johnpye	962	def testnewton(self):
180	johnpye	973	sys.stderr.write("STARTING TESTNEWTON\n")
181	johnpye	962	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	johnpye	963	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	johnpye	962	I.setReporter(ascpy.IntegratorReporterConsole(I))
196	johnpye	1017	I.setLinearTimesteps(ascpy.Units("s"), 0, 2*float(M.v)/float(M.g), 2)
197	johnpye	962	I.analyse()
198			I.solve()
199			print "At end of simulation,"
200	johnpye	979	print "x = %f" % M.x
201			print "v = %f" % M.v
202	johnpye	962	M.run(T.getMethod('self_test'))
203
204	johnpye	961	def testlotka(self):
205			self.L.load('johnpye/lotka.a4c')
206			M = self.L.findType('lotka').getSimulation('sim')
207	johnpye	980	M.setSolver(ascpy.Solver("QRSlv"))
208	johnpye	961	I = ascpy.Integrator(M)
209			I.setEngine('LSODE')
210			I.setReporter(ascpy.IntegratorReporterConsole(I))
211	johnpye	1017	I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 5)
212	johnpye	961	I.analyse()
213	johnpye	979	print "Number of vars = %d" % I.getNumVars()
214			assert I.getNumVars()==2
215	johnpye	961	I.solve()
216			assert I.getNumObservedVars() == 3;
217	johnpye	979	assert abs(M.R - 832) < 1.0
218			assert abs(M.F - 21.36) < 0.1
219	johnpye	1017
220			#-------------------------------------------------------------------------------
221	johnpye	1032	# Testing of a external blackbox functions
222	johnpye	1021
223	johnpye	1032	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			M = self.L.findType('fail1').getSimulation('sim')
263	johnpye	1034	try:
264			M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())
265			self.fail("expected exception was not raised")
266			except RuntimeError,e:
267			print "Caught exception '%s', assumed ok" % e
268	johnpye	1032
269			def testfail2(self):
270			"""Incorrect data arg check -- tests bbox, not ascend"""
271			self.L.load('test/blackbox/fail2.a4c')
272			M = self.L.findType('fail2').getSimulation('sim')
273			M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())
274
275			def testpass1(self):
276			"""simple single bbox forward solve"""
277			M = self._run('pass1',filename='test/blackbox/pass.a4c')
278
279			def testpass2(self):
280			"""simple single bbox reverse solve"""
281			M = self._run('pass2',filename='test/blackbox/pass.a4c')
282
283			def testpass3(self):
284			"""simple double bbox solve"""
285			M = self._run('pass3',filename='test/blackbox/pass3.a4c')
286
287			def testpass4(self):
288			"""simple double bbox reverse solve"""
289			M = self._run('pass4',filename='test/blackbox/pass3.a4c')
290
291			def testpass5(self):
292			M = self._run('pass5',filename='test/blackbox/pass5.a4c')
293
294			def testpass6(self):
295			M = self._run('pass6',filename='test/blackbox/pass5.a4c')
296
297			def testpass7(self):
298			M = self._run('pass7',filename='test/blackbox/passmerge.a4c')
299
300			def testpass8(self):
301			M = self._run('pass8',filename='test/blackbox/passmerge.a4c')
302
303			def testpass9(self):
304			M = self._run('pass9',filename='test/blackbox/passmerge.a4c')
305
306			def testpass10(self):
307			M = self._run('pass10',filename='test/blackbox/passmerge.a4c')
308
309			def testpass11(self):
310			M = self._run('pass11',filename='test/blackbox/passmerge.a4c')
311
312			def testpass12(self):
313			M = self._run('pass12',filename='test/blackbox/passmerge.a4c')
314
315			def testpass13(self):
316			"""cross-merged input/output solve"""
317			M = self._run('pass13',filename='test/blackbox/passmerge.a4c')
318
319			def testpass14(self):
320			"""cross-merged input/output reverse solve"""
321			M = self._run('pass14',filename='test/blackbox/passmerge.a4c')
322
323			def testpass20(self):
324			M = self._run('pass20',filename='test/blackbox/passarray.a4c')
325
326			def testparsefail21(self):
327			"""dense array of black boxes wrong syntax"""
328			try:
329			self.L.load('test/blackbox/parsefail21.a4c')
330			self.fail("parsefail21 should not have loaded without errors")
331			except:
332			pass
333
334			def testpass22(self):
335			M = self._run('pass22',filename='test/blackbox/passarray.a4c')
336
337			def testpass23(self):
338			M = self._run('pass23',filename='test/blackbox/passarray.a4c')
339
340			def testpass61(self):
341			M = self._run('pass61',filename='test/blackbox/reinstantiate.a4c')
342
343			def testpass62(self):
344			M = self._run('pass62',filename='test/blackbox/reinstantiate.a4c')
345
346			def testpass64(self):
347			M = self._run('pass64',filename='test/blackbox/reinstantiate.a4c')
348
349			def testpass65(self):
350			M = self._run('pass65',filename='test/blackbox/reinstantiate.a4c')
351
352			def testpass66(self):
353			M = self._run('pass66',filename='test/blackbox/reinstantiate.a4c')
354
355			def testpass67(self):
356			M = self._run('pass67',filename='test/blackbox/reinstantiate.a4c')
357
358	johnpye	1024	class TestExtFn(AscendSelfTester):
359	johnpye	1021	def testextfntest(self):
360	johnpye	1024	M = self._run('extfntest',filename='johnpye/extfn/extfntest.a4c')
361			self.assertAlmostEqual(M.y, 2);
362			self.assertAlmostEqual(M.x, 1);
363	johnpye	1021	self.assertAlmostEqual(M.y, M.x + 1);
364
365	johnpye	1024	# THIS TEST FAILS
366			# def testextrelfor(self):
367			# self.L.load('johnpye/extfn/extrelfor.a4c')
368			# T = self.L.findType('extrelfor')
369			# M = T.getSimulation('sim')
370			# M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
371			# print "x[1] = %f" % M.x[1]
372			# print "x[2] = %f" % M.x[2]
373			# print "x[3] = %f" % M.x[3]
374			# M.run(T.getMethod('self_test'))
375
376			def testextrelrepeat(self):
377			M = self._run('extrelrepeat',filename='johnpye/extfn/extrelrepeat.a4c')
378
379	johnpye	1021	#-------------------------------------------------------------------------------
380	johnpye	1024	# Testing of a ExtPy - external python methods
381
382			class TestExtPy(AscendSelfTester):
383			def testextpytest(self):
384	johnpye	1026	print "-------------------=--=-=-=-"
385	johnpye	1024	M = self._run('extpytest',filename='johnpye/extpy/extpytest.a4c')
386
387			#-------------------------------------------------------------------------------
388	johnpye	1017	# Testing of freesteam external steam properties functions
389
390	johnpye	1032	with_freesteam = True
391	johnpye	1017	try:
392			import freesteam
393			have_freesteam = True
394	johnpye	1018	except ImportError,e:
395	johnpye	1017	have_freesteam = False
396
397	johnpye	1024	if with_freesteam and have_freesteam:
398	johnpye	1017	class TestFreesteam(Ascend):
399	johnpye	1021	def testload(self):
400	johnpye	1017	self.L.load('johnpye/thermalequilibrium2.a4c')
401	johnpye	1018
402	johnpye	1021	def testinstantiate(self):
403			self.testload()
404	johnpye	1018	M = self.L.findType('thermalequilibrium2').getSimulation('sim')
405	johnpye	1021
406			def testsolve(self):
407			self.testinstantiate()
408	johnpye	1018	M.setSolver(ascpy.Solver("QRSlv"))
409	johnpye	1017	#I = ascpy.Integrator(M)
410			#I.setEngine('LSODE')
411			#I.setReporter(ascpy.IntegratorReporterConsole(I))
412			#I.setLinearTimesteps(ascpy.Units("s"), 0, 3000, 30)
413			#I.setMinSubStep(0.01)
414			#I.setInitialSubStep(0.1)
415			#I.analyse()
416			#print "Number of vars = %d" % I.getNumVars()
417			#assert I.getNumVars()==2
418			#I.solve()
419			#assert I.getNumObservedVars() == 3;
420			#assert abs(M.R - 832) < 1.0
421			#assert abs(M.F - 21.36) < 0.1
422
423
424			#-------------------------------------------------------------------------------
425			# Testing of IDA models using DENSE linear solver
426
427	johnpye	1016	class TestIDADENSE(Ascend):
428	johnpye	1017	"""IDA DAE integrator, DENSE linear solver"""
429	johnpye	961
430	johnpye	979	def testnewton(self):
431			sys.stderr.write("STARTING TESTNEWTON\n")
432			self.L.load('johnpye/newton.a4c')
433			T = self.L.findType('newton')
434			M = T.getSimulation('sim')
435			M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())
436			I = ascpy.Integrator(M)
437			I.setEngine('IDA')
438	johnpye	1016	I.setParameter('linsolver','DENSE')
439	johnpye	979	I.setParameter('safeeval',True)
440			I.setParameter('rtol',1e-8)
441			I.setMaxSubStep(0.001)
442			I.setMaxSubSteps(10000)
443
444			I.setReporter(ascpy.IntegratorReporterConsole(I))
445	johnpye	1017	I.setLinearTimesteps(ascpy.Units("s"), 0, 2*float(M.v)/float(M.g), 2)
446	johnpye	979	I.analyse()
447			I.solve()
448			print "At end of simulation,"
449			print "x = %f" % M.x
450			print "v = %f" % M.v
451			M.run(T.getMethod('self_test'))
452
453	johnpye	991	def testlotkaDENSE(self):
454			self.L.load('johnpye/lotka.a4c')
455			M = self.L.findType('lotka').getSimulation('sim')
456			M.setSolver(ascpy.Solver("QRSlv"))
457			I = ascpy.Integrator(M)
458			I.setEngine('IDA')
459			I.setReporter(ascpy.IntegratorReporterConsole(I))
460			I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 5);
461			I.setParameter('linsolver','DENSE')
462			I.setParameter('rtol',1e-8);
463			I.analyse()
464			assert I.getNumVars()==2
465			assert abs(M.R - 1000) < 1e-300
466			I.solve()
467	johnpye	1017	assert I.getNumObservedVars() == 3
468	johnpye	991	assert abs(M.R - 832) < 1.0
469			assert abs(M.F - 21.36) < 0.1
470	johnpye	972
471	johnpye	975	def testdenx(self):
472	johnpye	1026	print "-----------------------------====="
473	johnpye	942	self.L.load('johnpye/idadenx.a4c')
474			M = self.L.findType('idadenx').getSimulation('sim')
475	johnpye	1017	M.setSolver(ascpy.Solver("QRSlv"))
476	johnpye	942	I = ascpy.Integrator(M)
477			I.setEngine('IDA')
478	johnpye	1024	I.setParameter('calcic','YA_YPD')
479	johnpye	972	I.setParameter('linsolver','DENSE')
480	johnpye	944	I.setReporter(ascpy.IntegratorReporterConsole(I))
481	johnpye	1017	I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11)
482	johnpye	950	I.setMaxSubStep(0);
483	johnpye	1017	I.setInitialSubStep(0)
484	johnpye	950	I.setMaxSubSteps(0);
485	johnpye	944	I.setParameter('autodiff',True)
486			I.analyse()
487			I.solve()
488	johnpye	1022	assert abs(float(M.y1) - 5.1091e-08) < 2e-9
489			assert abs(float(M.y2) - 2.0437e-13) < 2e-14
490	johnpye	1017	assert abs(float(M.y3) - 1.0) < 1e-5
491	johnpye	942
492	johnpye	990	def testkryxDENSE(self):
493			self.L.load('johnpye/idakryx.a4c')
494			M = self.L.findType('idakryx').getSimulation('sim')
495			M.setSolver(ascpy.Solver('QRSlv'))
496			M.build()
497			I = ascpy.Integrator(M)
498			I.setEngine('IDA')
499			I.setReporter(ascpy.IntegratorReporterConsole(I))
500			I.setParameter('linsolver','DENSE')
501			I.setParameter('maxl',8)
502			I.setParameter('gsmodified',False)
503			I.setParameter('autodiff',True)
504			I.setParameter('rtol',0)
505			I.setParameter('atol',1e-3);
506			I.setParameter('atolvect',False)
507	johnpye	1016	I.setParameter('calcic','YA_YDP')
508	johnpye	990	I.analyse()
509	johnpye	1017	I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 11)
510	johnpye	990	I.solve()
511			assert abs(M.u[2][2].getValue()) < 1e-5
512	johnpye	1017
513			#-------------------------------------------------------------------------------
514			# Testing of IDA models using SPGMR linear solver (Krylov)
515
516	johnpye	1016	# these tests are disabled until SPGMR preconditioning has been implemented
517			class TestIDASPGMR:#(Ascend):
518			def testlotka(self):
519			self.L.load('johnpye/lotka.a4c')
520			M = self.L.findType('lotka').getSimulation('sim')
521			M.setSolver(ascpy.Solver("QRSlv"))
522	johnpye	951	I = ascpy.Integrator(M)
523			I.setEngine('IDA')
524			I.setReporter(ascpy.IntegratorReporterConsole(I))
525	johnpye	1017	I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 5)
526			I.setParameter('rtol',1e-8)
527	johnpye	951	I.analyse()
528	johnpye	1016	assert I.getNumVars()==2
529			assert abs(M.R - 1000) < 1e-300
530	johnpye	951	I.solve()
531	johnpye	1017	assert I.getNumObservedVars() == 3
532	johnpye	1016	assert abs(M.R - 832) < 1.0
533			assert abs(M.F - 21.36) < 0.1
534	johnpye	951
535	johnpye	1016
536	johnpye	991	def testkryx(self):
537	johnpye	951	self.L.load('johnpye/idakryx.a4c')
538			M = self.L.findType('idakryx').getSimulation('sim')
539	johnpye	952	M.build()
540	johnpye	951	I = ascpy.Integrator(M)
541			I.setEngine('IDA')
542			I.setReporter(ascpy.IntegratorReporterConsole(I))
543	johnpye	992	I.setParameter('linsolver','SPGMR')
544	johnpye	993	I.setParameter('prec','JACOBI')
545	johnpye	970	I.setParameter('maxl',8)
546	johnpye	952	I.setParameter('gsmodified',False)
547			I.setParameter('autodiff',True)
548	johnpye	993	I.setParameter('gsmodified',True)
549	johnpye	952	I.setParameter('rtol',0)
550			I.setParameter('atol',1e-3);
551			I.setParameter('atolvect',False)
552	johnpye	993	I.setParameter('calcic','Y')
553	johnpye	952	I.analyse()
554			I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 10);
555	johnpye	1017	print M.udot[1][3]
556	johnpye	952	I.solve()
557			assert 0
558	johnpye	967
559	johnpye	1016	def testzill(self):
560			self.L.load('johnpye/zill.a4c')
561			T = self.L.findType('zill')
562			M = T.getSimulation('sim')
563			M.setSolver(ascpy.Solver('QRSlv'))
564			I = ascpy.Integrator(M)
565			I.setEngine('IDA')
566			I.setParameter('safeeval',False)
567			I.setMinSubStep(1e-7)
568			I.setMaxSubStep(0.001)
569			I.setMaxSubSteps(10000)
570			I.setReporter(ascpy.IntegratorReporterConsole(I))
571	johnpye	1017	I.setLinearTimesteps(ascpy.Units(), 1.0, 1.5, 5)
572	johnpye	1016	I.analyse()
573			I.solve()
574			M.run(T.getMethod('self_test'))
575
576			def testdenxSPGMR(self):
577			self.L.load('johnpye/idadenx.a4c')
578			M = self.L.findType('idadenx').getSimulation('sim')
579			M.setSolver(ascpy.Solver('QRSlv'))
580			I = ascpy.Integrator(M)
581			I.setEngine('IDA')
582			I.setReporter(ascpy.IntegratorReporterConsole(I))
583	johnpye	1017	I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11)
584	johnpye	1016	I.setMaxSubStep(0);
585			I.setInitialSubStep(0);
586			I.setMaxSubSteps(0);
587			I.setParameter('autodiff',True)
588			I.setParameter('linsolver','SPGMR')
589			I.setParameter('gsmodified',False)
590			I.setParameter('maxncf',10)
591			I.analyse()
592			I.solve()
593	johnpye	1017	assert abs(float(M.y1) - 5.1091e-08) < 1e-10
594			assert abs(float(M.y2) - 2.0437e-13) < 1e-15
595			assert abs(float(M.y3) - 1.0) < 1e-5
596	johnpye	1016
597	johnpye	943	# move code above down here if you want to temporarily avoid testing it
598	johnpye	932	class NotToBeTested:
599			def nothing(self):
600			pass
601	johnpye	1016
602	johnpye	669	if __name__=='__main__':
603	johnpye	966	atexit.register(ascpy.shutdown)
604	johnpye	1008	#suite = unittest.TestSuite()
605	johnpye	1003	#suite = unittest.defaultTestLoader.loadTestsFromName('__main__')
606	johnpye	1008	#unittest.TextTestRunner(verbosity=2).run(suite)
607			unittest.main()