/[ascend]/trunk/test.py
ViewVC logotype

Diff of /trunk/test.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/pygtk/test.py revision 1021 by johnpye, Wed Jan 3 07:40:24 2007 UTC trunk/test.py revision 1339 by jpye, Sat Mar 10 13:57:01 2007 UTC
# Line 1  Line 1 
1  #!/usr/bin/env python  #!/usr/bin/env python
2    #   ASCEND modelling environment
3    #   Copyright (C) 2006, 2007 Carnegie Mellon University
4    #
5    #   This program is free software; you can redistribute it and/or modify
6    #   it under the terms of the GNU General Public License as published by
7    #   the Free Software Foundation; either version 2, or (at your option)
8    #   any later version.
9    #
10    #   This program is distributed in the hope that it will be useful,
11    #   but WITHOUT ANY WARRANTY; without even the implied warranty of
12    #   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13    #   GNU General Public License for more details.
14    #
15    #   You should have received a copy of the GNU General Public License
16    #   along with this program; if not, write to the Free Software
17    #   Foundation, Inc., 59 Temple Place - Suite 330,
18    #   Boston, MA 02111-1307, USA.
19    
20    # This script gives a test suite for the high-level interface of ASCEND via
21    # Python. It is also planned to be a wrapper for the CUnit test suite, although
22    # this is still experimental.
23    
24  import unittest  import unittest
25  import ascpy  import os, sys
26  import math  import math
 import os, subprocess, sys  
27  import atexit  import atexit
28  import cunit  
29    import platform
30    if platform.system() != "Windows":
31        try:
32            import dl
33            _dlflags = dl.RTLD_GLOBAL|dl.RTLD_NOW
34        except:
35            # On platforms that unilaterally refuse to provide the 'dl' module
36            # we'll just set the value and see if it works.
37            print "Note: python 'dl' module not available on this system, guessing value of RTLD_* flags"
38            _dlflags = 258
39    
40        sys.setdlopenflags(_dlflags)
41    
42  class Ascend(unittest.TestCase):  class Ascend(unittest.TestCase):
43    
# Line 16  class Ascend(unittest.TestCase): Line 49  class Ascend(unittest.TestCase):
49          self.L.clear()          self.L.clear()
50          del self.L          del self.L
51    
52    class AscendSelfTester(Ascend):
53    
54        def _run(self,modelname,solvername="QRSlv",filename=None,parameters={}):
55            if filename==None:
56                filename = 'johnpye/%s.a4c' % modelname
57            self.L.load(filename)
58            T = self.L.findType(modelname)
59            M = T.getSimulation('sim')
60            M.setSolver(ascpy.Solver(solvername))
61            for k,v in parameters.iteritems():
62                M.setParameter(k,v)
63            M.solve(ascpy.Solver(solvername),ascpy.SolverReporter())    
64            M.run(T.getMethod('self_test'))
65            return M
66    
67  class TestCompiler(Ascend):  class TestCompiler(Ascend):
68    
69        def _run(self,filen,modeln=""):
70            self.L.load('test/compiler/%s.a4c' % filen)
71            T = self.L.findType('%s%s' % (filen,modeln))
72            M = T.getSimulation('sim')
73            M.build()
74    
75        def _runfail(self,filen,n,msg="failed"):
76            try:
77                self._run(filen,'fail%d' % n)
78            except Exception,e:
79                print "(EXPECTED) ERROR: %s" % e
80                return
81            self.fail(msg)
82    
83    
84      def testloading(self):      def testloading(self):
85            """library startup"""
86          pass          pass
87    
88      def testsystema4l(self):      def testsystema4l(self):
89            """loading system.a4l?"""
90          self.L.load('system.a4l')          self.L.load('system.a4l')
91    
92      def testatomsa4l(self):      def testatomsa4l(self):
93            """loading atoms.a4l?"""
94          self.L.load('atoms.a4l')          self.L.load('atoms.a4l')
95    
96  class TestSolver(Ascend):      def testmissingreq(self):
97                """flagging a missing REQUIRE"""
98      def _run(self,modelname,solvername="QRSlv",filename=None):          self._runfail('missingreq',1)
99          if filename==None:  
100              filename = 'johnpye/%s.a4c' % modelname      def testmissingsubreq(self):
101          self.L.load(filename)          """flagging a subsidiary missing REQUIRE"""
102            self._runfail('missingreq',1)
103    
104        def defaultmethodstest(self,modelname):
105            self.L.load("test/defaultmethods.a4c")
106          T = self.L.findType(modelname)          T = self.L.findType(modelname)
107          M = T.getSimulation('sim')          M = T.getSimulation('sim')
108          M.build()          M.run(T.getMethod('on_load'))
         M.solve(ascpy.Solver(solvername),ascpy.SolverReporter())      
109          M.run(T.getMethod('self_test'))          M.run(T.getMethod('self_test'))
110            return M
111    
112        def testdefault1(self):
113            self.defaultmethodstest('testdefault1')
114    
115        def testdefault2(self):
116            self.defaultmethodstest('testdefault2')
117    
118        def testdefault3(self):
119            self.defaultmethodstest('testdefault3')
120    
121        def testdefault4(self):
122            self.defaultmethodstest('testdefault4')
123    
124        def testdefault5(self):
125            self.defaultmethodstest('testdefault5')
126    
127        def testdefault6(self):
128            self.defaultmethodstest('testdefault6')
129    
130        def testdefault7(self):
131            self.defaultmethodstest('testdefault7')
132    
133        def testdefault8(self):
134            self.defaultmethodstest('testdefault8')
135    
136        def testdefault9(self):
137            self.defaultmethodstest('testdefault9')
138    
139        def testdefault10(self):
140            self.defaultmethodstest('testdefault10')
141    
142        def testdefault11(self):
143            self.defaultmethodstest('testdefault11')
144    
145        def testdefault12(self):
146            self.defaultmethodstest('testdefault12')
147    
148        def testdefault13(self):
149            self.defaultmethodstest('testdefault13')
150    
151        def testdefault14(self):
152            self.defaultmethodstest('testdefault14')
153    
154        def testdefault15(self):
155            self.defaultmethodstest('testdefault15')
156    
157        def testdefault16(self):
158            self.defaultmethodstest('testdefault16')
159    
160        def testdefault17(self):
161            self.defaultmethodstest('testdefault17')
162        def testdefault18(self):
163            self.defaultmethodstest('testdefault18')
164    
165    class TestSolver(AscendSelfTester):
166        
167      def testlog10(self):      def testlog10(self):
168          self._run('testlog10')          self._run('testlog10')
169    
170        def testrootsofpoly(self):
171            self._run('roots_of_poly',filename="roots_of_poly.a4c")
172    
173        def testcollapsingcan(self):
174            self._run('collapsingcan',filename="collapsingcan.a4c")
175    
176        def testdistancecalc(self):
177            self._run('distance_calc',filename="distance_calc.a4c")
178    
179      def testconopt(self):      def testconopt(self):
180          self._run('testconopt',"CONOPT")                          self._run('testconopt',"CONOPT")                
181    
# Line 66  class TestSolver(Ascend): Line 200  class TestSolver(Ascend):
200      def testsunpos6(self):      def testsunpos6(self):
201          self._run('example_1_8_1',"QRSlv","johnpye/sunpos.a4c")          self._run('example_1_8_1',"QRSlv","johnpye/sunpos.a4c")
202    
203        def testinstanceas(self):
204            M = self._run('example_1_6_1',"QRSlv","johnpye/sunpos.a4c")
205            self.assertAlmostEqual( float(M.t_solar), M.t_solar.as("s"))
206            self.assertAlmostEqual( float(M.t_solar)/3600, M.t_solar.as("h"))
207    
208    
209    class TestCMSlv(AscendSelfTester):
210        def testheatex(self):
211            self._run('heatex',"CMSlv","heatex.a4c")
212        def testphaseeq(self):
213            self._run('phaseq',"CMSlv","phaseq.a4c")
214        def testpipeline(self):
215            self._run('pipeline',"CMSlv","pipeline.a4c"
216                ,{'infinity':3.2e9}
217            )
218        def testrachford(self):
219            self._run('rachford',"CMSlv","rachford.a4c")
220        def testlinmassbal(self):
221            self._run('linmassbal',"CMSlv","linmassbal.a4c")
222    
223    
224    class TestMatrix(AscendSelfTester):
225        def testlog10(self):
226            M = self._run('testlog10')
227            print M.getMatrix().write(sys.stderr,"mmio")
228    
229            
230  class TestIntegrator(Ascend):  class TestIntegrator(Ascend):
231    
232      def testListIntegrators(self):      def testListIntegrators(self):
# Line 79  class TestIntegrator(Ascend): Line 240  class TestIntegrator(Ascend):
240          self.L.load('johnpye/shm.a4c')          self.L.load('johnpye/shm.a4c')
241          M = self.L.findType('shm').getSimulation('sim')          M = self.L.findType('shm').getSimulation('sim')
242          M.setSolver(ascpy.Solver('QRSlv'))          M.setSolver(ascpy.Solver('QRSlv'))
243            P = M.getParameters()
244            M.setParameter('feastol',1e-12)
245          print M.getChildren()          print M.getChildren()
246          assert float(M.x) == 10.0          assert float(M.x) == 10.0
247          assert float(M.v) == 0.0          assert float(M.v) == 0.0
# Line 88  class TestIntegrator(Ascend): Line 251  class TestIntegrator(Ascend):
251          I.setReporter(ascpy.IntegratorReporterNull(I))          I.setReporter(ascpy.IntegratorReporterNull(I))
252          I.setEngine(integratorname);          I.setEngine(integratorname);
253          I.setLinearTimesteps(ascpy.Units("s"), 0.0, t_end, 100);          I.setLinearTimesteps(ascpy.Units("s"), 0.0, t_end, 100);
254          I.setMinSubStep(0.0005); # these limits are required by IDA at present (numeric diff)          I.setMinSubStep(0.0001); # these limits are required by IDA at present (numeric diff)
255          I.setMaxSubStep(0.02);          I.setMaxSubStep(0.1);
256          I.setInitialSubStep(0.001);          I.setInitialSubStep(0.001);
257          I.setMaxSubSteps(200);          I.setMaxSubSteps(200);
258          if(integratorname=='IDA'):          if(integratorname=='IDA'):
259              I.setParameter('autodiff',False)              I.setParameter('autodiff',False)
260            for p in M.getParameters():
261                print p.getName(),"=",p.getValue()
262          I.analyse();          I.analyse();
263          I.solve();          I.solve();
264          print "At end of simulation,"          print "At end of simulation,"
# Line 129  class TestIntegrator(Ascend): Line 294  class TestIntegrator(Ascend):
294          P = I.getParameters()          P = I.getParameters()
295          for p in P:          for p in P:
296              print p.getName(),"=",p.getValue()              print p.getName(),"=",p.getValue()
297          assert len(P)==11          assert len(P)==12
298          assert P[0].isStr()          assert P[0].isStr()
299          assert P[0].getName()=="linsolver"          assert P[0].getName()=="linsolver"
300          assert P[0].getValue()=='SPGMR'          assert P[0].getValue()=='DENSE'
301          assert P[2].getName()=="autodiff"          assert P[2].getName()=="maxord"
302          assert P[2].getValue()==True          assert P[3].getName()=="autodiff"
303          assert P[7].getName()=="atolvect"          assert P[3].getValue()==True
304          assert P[7].getBoolValue() == True          assert P[8].getName()=="atolvect"
305          P[2].setBoolValue(False)          assert P[8].getBoolValue() == True
306          assert P[2].getBoolValue()==False          P[3].setBoolValue(False)
307            assert P[3].getBoolValue()==False
308          I.setParameters(P)          I.setParameters(P)
309          assert I.getParameterValue('autodiff')==False          assert I.getParameterValue('autodiff')==False
310          I.setParameter('autodiff',True)          I.setParameter('autodiff',True)
# Line 209  class TestLSODE(Ascend): Line 375  class TestLSODE(Ascend):
375          assert abs(M.F - 21.36) < 0.1          assert abs(M.F - 21.36) < 0.1
376    
377  #-------------------------------------------------------------------------------  #-------------------------------------------------------------------------------
378  # Testing of a simple external function  # Testing of a external blackbox functions
379    
380    class TestBlackBox(AscendSelfTester):
381        def testparsefail0(self):
382            try:
383                self.L.load('test/blackbox/parsefail0.a4c')
384                self.fail("parsefail0 should not have loaded without errors")
385            except:
386                pass
387    
388        def testparsefail1(self):
389            try:
390                self.L.load('test/blackbox/parsefail1.a4c')
391                self.fail("parsefail1 should not have loaded without errors")
392            except:
393                pass
394    
395        def testparsefail2(self):
396            try:
397                self.L.load('test/blackbox/parsefail2.a4c')
398                self.fail("parsefail2 should not have loaded without errors")
399            except:
400                pass
401    
402        def testparsefail3(self):
403            try:
404                self.L.load('test/blackbox/parsefail3.a4c')
405                self.fail("parsefail3 should not have loaded without errors")
406            except:
407                pass
408    
409        def testparsefail4(self):
410            try:
411                self.L.load('test/blackbox/parsefail4.a4c')
412                self.fail("parsefail4 should not have loaded")
413            except:
414                pass
415    
416        def testfail1(self):
417            """Mismatched arg counts check-- tests bbox, not ascend."""
418            self.L.load('test/blackbox/fail1.a4c')
419            try:
420                M = self.L.findType('fail1').getSimulation('sim')
421                self.fail("expected exception was not raised")
422            except RuntimeError,e:
423                print "Caught exception '%s', assumed ok" % e
424    
425        def testfail2(self):
426            """Incorrect data arg check -- tests bbox, not ascend"""
427            self.L.load('test/blackbox/fail2.a4c')
428            try:
429                M = self.L.findType('fail2').getSimulation('sim')
430                self.fail("expected exception was not raised")
431            except RuntimeError,e:
432                print "Caught exception '%s', assumed ok (should mention errors during instantiation)" % e
433    
434        def testpass1(self):
435            """simple single bbox forward solve"""
436            M = self._run('pass1',filename='test/blackbox/pass.a4c')
437    
438        def testpass2(self):
439            """simple single bbox reverse solve"""
440            M = self._run('pass2',filename='test/blackbox/pass.a4c')
441    
442        def testpass3(self):
443            """simple double bbox solve"""
444            M = self._run('pass3',filename='test/blackbox/pass3.a4c')
445    
446        def testpass4(self):
447            """simple double bbox reverse solve"""
448            M = self._run('pass4',filename='test/blackbox/pass3.a4c')
449    
450        def testpass5(self):
451            M = self._run('pass5',filename='test/blackbox/pass5.a4c')
452    
453        def testpass6(self):
454            M = self._run('pass6',filename='test/blackbox/pass5.a4c')
455    
456        def testpass7(self):
457            M = self._run('pass7',filename='test/blackbox/passmerge.a4c')
458    
459        def testpass8(self):
460            M = self._run('pass8',filename='test/blackbox/passmerge.a4c')
461    
462  class TestExtFn(Ascend):      def testpass9(self):
463            M = self._run('pass9',filename='test/blackbox/passmerge.a4c')
464    
465        def testpass10(self):
466            M = self._run('pass10',filename='test/blackbox/passmerge.a4c')
467    
468        def testpass11(self):
469            M = self._run('pass11',filename='test/blackbox/passmerge.a4c')
470    
471        def testpass12(self):
472            M = self._run('pass12',filename='test/blackbox/passmerge.a4c')
473    
474    # this test doesn't work: 'system is inconsistent' -- and structurally singular
475    #   def testpass13(self):
476    #       """cross-merged input/output solve"""
477    #       M = self._run('pass13',filename='test/blackbox/passmerge.a4c')
478    
479        def testpass14(self):
480            """cross-merged input/output reverse solve"""
481            M = self._run('pass14',filename='test/blackbox/passmerge.a4c')
482    
483        def testpass20(self):
484            M = self._run('pass20',filename='test/blackbox/passarray.a4c')
485    
486        def testparsefail21(self):
487            """dense array of black boxes wrong syntax"""
488            try:
489                self.L.load('test/blackbox/parsefail21.a4c')
490                self.fail("parsefail21 should not have loaded without errors")
491            except:
492                pass
493    
494        def testpass22(self):
495            M = self._run('pass22',filename='test/blackbox/passarray.a4c')
496    
497        def testpass23(self):
498            M = self._run('pass23',filename='test/blackbox/passarray.a4c')
499    
500        def testpass61(self):
501            M = self._run('pass61',filename='test/blackbox/reinstantiate.a4c')
502    
503        def testpass62(self):
504            M = self._run('pass62',filename='test/blackbox/reinstantiate.a4c')
505    
506        def testpass64(self):
507            M = self._run('pass64',filename='test/blackbox/reinstantiate.a4c')
508    
509        def testpass65(self):
510            M = self._run('pass65',filename='test/blackbox/reinstantiate.a4c')
511    
512        def testpass66(self):
513            M = self._run('pass66',filename='test/blackbox/reinstantiate.a4c')
514    
515        def testpass67(self):
516            M = self._run('pass67',filename='test/blackbox/reinstantiate.a4c')
517    
518    class TestExtFn(AscendSelfTester):
519      def testextfntest(self):      def testextfntest(self):
520          self.L.load('johnpye/extfn/extfntest.a4c')          M = self._run('extfntest',filename='johnpye/extfn/extfntest.a4c')
521          M = self.L.findType('extfntest').getSimulation('sim')          self.assertAlmostEqual(M.y, 2);
522          M.build()          self.assertAlmostEqual(M.x, 1);
         M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())  
         print "y = %f" % M.y  
         print "x = %f" % M.x  
         self.assertAlmostEqual(M.y, 1);  
         self.assertAlmostEqual(M.x, 0);  
523          self.assertAlmostEqual(M.y, M.x + 1);          self.assertAlmostEqual(M.y, M.x + 1);
524    
525        def testextrelfor(self):
526            M = self._run('extrelfor',filename='johnpye/extfn/extrelfor.a4c')
527    
528    ## @TODO fix bug with badly-named bbox rel in a loop (Ben, maybe)
529    #   def testextrelforbadnaming(self):
530    #       self.L.load('johnpye/extfn/extrelforbadnaming.a4c')
531    #       T = self.L.findType('extrelfor')
532    #       M = T.getSimulation('sim')
533    #       M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
534    #       print "x[1] = %f" % M.x[1]
535    #       print "x[2] = %f" % M.x[2]
536    #       print "x[3] = %f" % M.x[3]
537    #       print "x[4] = %f" % M.x[4]
538    #       print "x[5] = %f" % M.x[5]
539    #       M.run(T.getMethod('self_test'))
540    
541        def testextrelrepeat(self):
542            M = self._run('extrelrepeat',filename='johnpye/extfn/extrelrepeat.a4c')
543    
544    #-------------------------------------------------------------------------------
545    # Testing of Sensitivity module
546    
547    class TestSensitivity(AscendSelfTester):
548        def test1(self):
549            self.L.load('sensitivity_test.a4c')
550            T = self.L.findType('sensitivity_test')
551            M = T.getSimulation('sim',False)
552            M.run(T.getMethod('on_load'))
553            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
554            M.run(T.getMethod('analyse'))
555            M.run(T.getMethod('self_test'))
556    
557    #   def testall(self):
558    #       self.L.load('sensitivity_test.a4c')
559    #       T = self.L.findType('sensitivity_test_all')
560    #       M = T.getSimulation('sim',False)
561    #       M.run(T.getMethod('on_load'))
562    #       M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
563    #       M.run(T.getMethod('analyse'))
564    #       M.run(T.getMethod('self_test'))
565    # CAUSES CRASH
566                    
567    #-------------------------------------------------------------------------------
568    # Testing of a ExtPy - external python methods
569    
570    class TestExtPy(AscendSelfTester):
571        def test1(self):
572            self.L.load('johnpye/extpy/extpytest.a4c')
573            T = self.L.findType('extpytest')
574            M = T.getSimulation('sim')
575            M.run(T.getMethod('self_test'))
576            
577        def test2(self):
578            self.L.load('johnpye/extpy/extpytest.a4c')
579            T = self.L.findType('extpytest')
580            M = T.getSimulation('sim')
581            M.run(T.getMethod('pythonthing'))
582            M.run(T.getMethod('pythonthing'))
583            M.run(T.getMethod('pythonthing'))
584            M.run(T.getMethod('pythonthing'))
585            M.run(T.getMethod('pythonthing'))
586            M.run(T.getMethod('pythonthing'))
587            M.run(T.getMethod('pythonthing'))
588            # causes crash!
589    
590    #-------------------------------------------------------------------------------
591    # Testing of saturated steam properties library (iapwssatprops.a4c)
592    
593    class TestSteam(AscendSelfTester):
594    
595        def testiapwssatprops1(self):
596            M = self._run('testiapwssatprops1',filename='steam/iapwssatprops.a4c')
597        def testiapwssatprops2(self):
598            M = self._run('testiapwssatprops2',filename='steam/iapwssatprops.a4c')
599        def testiapwssatprops3(self):
600            M = self._run('testiapwssatprops3',filename='steam/iapwssatprops.a4c')
601    
602        # test the stream model basically works
603        def testsatsteamstream(self):
604            M = self._run('satsteamstream',filename='steam/satsteamstream.a4c')
605    
606        # test that we can solve in terms of various (rho,u)
607        def testsatuv(self):
608            self.L.load('steam/iapwssat.a4c')
609            T = self.L.findType('testiapwssatuv')
610            M = T.getSimulation('sim',False)
611            M.run(T.getMethod('on_load'))
612            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
613            print "p = %f bar" % M.p.as('bar');
614            print "T = %f C" % (M.T.as('K') - 273.15);
615            print "x = %f" % M.x;
616            M.run(T.getMethod('self_test'))
617            M.run(T.getMethod('values2'))
618    #       M.v.setRealValueWithUnits(1.0/450,"m^3/kg");
619    #       M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
620            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
621            print "p = %f bar" % M.p.as('bar');
622            print "T = %f C" % (M.T.as('K') - 273.15);
623            print "x = %f" % M.x;
624            M.run(T.getMethod('self_test2'))
625            
626    
627    ## @TODO fix error capture from bounds checking during initialisation
628    #   def testiapwssat1(self):
629    #       M = self._run('testiapwssat1',filename='steam/iapwssat.a4c')
630    
631        def testdsgsat(self):
632            self.L.load('steam/dsgsat3.a4c')
633            T = self.L.findType('dsgsat3')
634            M = T.getSimulation('sim',False)
635            M.run(T.getMethod('on_load'))
636            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
637            self.assertAlmostEqual(M.dTw_dt[2],0.0);
638            M.run(T.getMethod('configure_dynamic'))
639            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
640            return M
641    
642        def testdsgsatrepeat(self):
643            self.L.load('steam/dsgsat3.a4c')
644            T = self.L.findType('dsgsat3')
645            M = T.getSimulation('sim',False)
646            M.run(T.getMethod('on_load'))
647            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
648            M.run(T.getMethod('on_load'))
649            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
650            M.run(T.getMethod('on_load'))
651            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
652    
653        def testvary(self):
654            self.L.load('steam/dsgsat3.a4c')
655            T = self.L.findType('dsgsat3')
656            M = T.getSimulation('sim',False)
657            M.run(T.getMethod('on_load'))
658            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
659            print "----- setting qdot_s -----"
660            M.qdot_s.setRealValueWithUnits(1000,"W/m")
661            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
662            print "----- setting qdot_s -----"
663            M.qdot_s.setRealValueWithUnits(2000,"W/m")
664            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
665    
666        def teststeadylsode(self):
667            "test that steady conditions are stable with LSODE"
668            M = self.testdsgsat()
669            #M.qdot_s.setRealValueWithUnits(1000,"W/m")
670            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
671            #M.setParameter('
672            I = ascpy.Integrator(M)
673            I.setEngine('LSODE')
674            I.setReporter(ascpy.IntegratorReporterConsole(I))
675            I.setLinearTimesteps(ascpy.Units("s"), 0, 3600, 10)
676            I.analyse()
677            I.solve()
678    
679    #   def testpeturblsode(self):
680    #       "test that steady conditions are stable with LSODE"
681    #       M = self.testdsgsat()
682    #       # here is the peturbation...
683    #       M.qdot_s.setRealValueWithUnits(1000,"W/m")
684    #       M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
685    #       I = ascpy.Integrator(M)
686    #       I.setEngine('LSODE')
687    #       I.setReporter(ascpy.IntegratorReporterConsole(I))
688    #       I.setLinearTimesteps(ascpy.Units("s"), 0, 5, 1)
689    #       I.analyse()
690    #       I.solve()
691    
692        def teststeadyida(self):    
693            M = self.testdsgsat()
694            self.assertAlmostEqual(M.dTw_dt[2],0.0)
695            Tw1 = float(M.T_w[2])
696            T = self.L.findType('dsgsat3')
697            M.run(T.getMethod('free_states'))
698            I = ascpy.Integrator(M)
699            I.setEngine('IDA')
700            I.setParameter('linsolver','DENSE')
701            I.setParameter('safeeval',True)
702            I.setParameter('rtol',1e-4)
703            I.setParameter('atolvect',False)
704            I.setParameter('atol',1e-4)
705            I.setParameter('maxord',3)      
706            I.setInitialSubStep(0.001)
707            I.setReporter(ascpy.IntegratorReporterConsole(I))
708            I.setLinearTimesteps(ascpy.Units("s"), 0, 3600, 10)
709            I.analyse()
710            I.solve()
711            self.assertAlmostEqual(float(M.T_w[2]),Tw1)
712            M.qdot_s.setRealValueWithUnits(1000,"W/m")
713            self.assertAlmostEqual(M.qdot_s.as("W/m"),1000)
714            M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
715            print "dTw/dt = %f" % M.dTw_dt[2]
716            self.assertNotAlmostEqual(M.dTw_dt[2],0.0)
717    
718        def testpeturbida(self):    
719            M = self.testdsgsat()
720            self.assertAlmostEqual(M.dTw_dt[2],0.0)
721            T = self.L.findType('dsgsat3')
722            M.run(T.getMethod('free_states'))
723            # here is the peturbation...
724            M.qdot_s.setRealValueWithUnits(6000,"W/m")
725            # IDA has its own initial conditions solver, so no need to call QRSlv here
726            I = ascpy.Integrator(M)
727            I.setEngine('IDA')
728            I.setParameter('linsolver','DENSE')
729            I.setParameter('safeeval',True)
730            I.setParameter('rtol',1e-4)
731            I.setParameter('atolvect',False)
732            I.setParameter('atol',1e-4)
733            I.setParameter('maxord',3)
734            I.setInitialSubStep(0.001)
735            I.setReporter(ascpy.IntegratorReporterConsole(I))
736            I.setLogTimesteps(ascpy.Units("s"), 0.001, 3600, 40)
737            I.analyse()
738            F = file('ga.mm','w')
739            I.writeMatrix(F,'dg/dz')
740            F = file('gd.mm','w')
741            I.writeMatrix(F,'dg/dx')
742            F = file('fa.mm','w')
743            I.writeMatrix(F,'df/dz')
744            F = file('fd.mm','w')
745            I.writeMatrix(F,'df/dx')
746            F = file('fdp.mm','w')
747            I.writeMatrix(F,"df/dx'")
748            I.solve()
749            
750  #-------------------------------------------------------------------------------  #-------------------------------------------------------------------------------
751  # Testing of freesteam external steam properties functions  # Testing of freesteam external steam properties functions
752    
753    with_freesteam = True
754  try:  try:
755        # we assume that if the freesteam python module is installed, the ASCEND
756        # external library will also be.
757      import freesteam      import freesteam
758      have_freesteam = True      have_freesteam = True
759  except ImportError,e:  except ImportError,e:
760      have_freesteam = False      have_freesteam = False
761    
762  if have_freesteam:  if with_freesteam and have_freesteam:
763      class TestFreesteam(Ascend):      class TestFreesteam(AscendSelfTester):
764    #       def testfreesteamtest(self):
765    #           """run the self-test cases bundled with freesteam"""
766    #           self._run('testfreesteam',filename='testfreesteam.a4c')
767    
768          def testload(self):          def testload(self):
769                """check that we can load 'thermalequilibrium2' (IMPORT "freesteam", etc)"""
770              self.L.load('johnpye/thermalequilibrium2.a4c')              self.L.load('johnpye/thermalequilibrium2.a4c')
771    
772          def testinstantiate(self):          def testinstantiate(self):
773                """load an instantiate 'thermalequilibrium2'"""
774              self.testload()              self.testload()
775              M = self.L.findType('thermalequilibrium2').getSimulation('sim')              M = self.L.findType('thermalequilibrium2').getSimulation('sim')
776                return M
777    
778          def testsolve(self):          def testintegrate(self):
779              self.testinstantiate()              """integrate transfer of heat from one mass of water/steam to another
780                according to Newton's law of cooling"""
781                M = self.testinstantiate()
782              M.setSolver(ascpy.Solver("QRSlv"))              M.setSolver(ascpy.Solver("QRSlv"))
783              #I = ascpy.Integrator(M)              I = ascpy.Integrator(M)
784              #I.setEngine('LSODE')              I.setEngine('LSODE')
785              #I.setReporter(ascpy.IntegratorReporterConsole(I))              I.setReporter(ascpy.IntegratorReporterConsole(I))
786              #I.setLinearTimesteps(ascpy.Units("s"), 0, 3000, 30)              I.setLinearTimesteps(ascpy.Units("s"), 0, 3000, 30)
787              #I.setMinSubStep(0.01)              I.setMinSubStep(0.01)
788              #I.setInitialSubStep(0.1)              I.setInitialSubStep(1)
789              #I.analyse()              I.analyse()
790              #print "Number of vars = %d" % I.getNumVars()              print "Number of vars = %d" % I.getNumVars()
791              #assert I.getNumVars()==2              assert I.getNumVars()==2
792              #I.solve()              I.solve()
793              #assert I.getNumObservedVars() == 3;              assert I.getNumObservedVars() == 3;
794              #assert abs(M.R - 832) < 1.0              print "S[1].T = %f K" % M.S[1].T
795              #assert abs(M.F - 21.36) < 0.1              print "S[2].T = %f K" % M.S[2].T
796                print "Q = %f W" % M.Q      
797                self.assertAlmostEqual(float(M.S[1].T),506.77225109,4);
798                self.assertAlmostEqual(float(M.S[2].T),511.605173967,5);
799                self.assertAlmostEqual(float(M.Q),-48.32922877329,3);
800                self.assertAlmostEqual(float(M.t),3000);
801                print "Note that the above values have not been verified analytically"
802    
803            def testcollapsingcan2(self):
804                """ solve the collapsing can model using IAPWS-IF97 steam props """
805                M = self._run("collapsingcan2",filename="collapsingcan2.a4c");
806    
807  #-------------------------------------------------------------------------------  #-------------------------------------------------------------------------------
808  # Testing of IDA models using DENSE linear solver  # Testing of IDA's analysis module
809    
810  class TestIDADENSE(Ascend):  class TestIDA(Ascend):
811      """IDA DAE integrator, DENSE linear solver"""      def _run(self,filen,modeln=""):
812            self.L.load('test/ida/%s.a4c' % filen)
813            T = self.L.findType('%s%s' % (filen,modeln))
814            M = T.getSimulation('sim')
815            M.build()
816            I = ascpy.Integrator(M)
817            I.setEngine('IDA')
818            I.analyse()
819            return M;
820    
821      def testnewton(self):      def _runfail(self,filen,n,msg="failed"):
822          sys.stderr.write("STARTING TESTNEWTON\n")          try:
823          self.L.load('johnpye/newton.a4c')              self._run(filen,'fail%d' % n)
824          T = self.L.findType('newton')          except Exception,e:
825                print "(EXPECTED) ERROR: %s" % e
826                return
827            self.fail(msg)
828    
829        def testsinglederiv(self):
830            self._run('singlederiv')
831    
832        def testsinglederivfail1(self):
833            self._runfail('singlederiv',1
834                ,"t.ode_id=-1 did not trigger error")
835    
836        def testsinglederivfail2(self):
837            self._runfail('singlederiv',2
838                ,"dy_dt.ode_id=2 did not trigger error")
839    
840        def testsinglederivfail3(self):
841            self._runfail('singlederiv',3
842                ,"dy_dt.ode_type=3 did not trigger error")
843    
844        def testsinglederivfail4(self):
845            self._runfail('singlederiv',4
846                ,"duplicate ode_type=1 did not trigger error")
847    
848        def testsinglederivfail5(self):
849            self._runfail('singlederiv',5
850                ,"duplicate ode_type=1 did not trigger error")
851    
852        def testsinglederivfail6(self):
853            self._runfail('singlederiv',6
854                ,"duplicate ode_type=1 did not trigger error")
855    
856        def testtwoderiv(self):
857            self._run('twoderiv')
858    
859        def testtwoderivfail1(self):
860            self._runfail('twoderiv',1)
861    
862        def testtwoderivfail2(self):
863            self._runfail('twoderiv',2)
864    
865        def testtwoderivfail3(self):
866            self._runfail('twoderiv',3)
867        def testtwoderivfail4(self):
868            self._runfail('twoderiv',4)
869        def testtwoderivfail5(self):
870            self._runfail('twoderiv',5)
871    
872        def testnoderivs(self):
873            self._runfail('noderivs',1)
874    
875        def testnoindeps(self):
876            self._runfail('indeps',1)
877    
878        def testtwoindeps(self):
879            self._runfail('indeps',2)
880    
881        def testfixedvars(self):
882            self._run('fixedvars')
883    
884        def testfixedvars1(self):
885            self._run('fixedvars',1)
886    
887    # fails the index check
888    #   def testfixedvars2(self):
889    #       self._run('fixedvars',2)
890    
891    # fails the index check
892    #   def testfixedvars3(self):
893    #       self._run('fixedvars',3)
894    
895        def testincidence(self):
896            self._run('incidence')
897    
898        def testincidence1(self):
899            self._run('incidence',1)
900        def testincidence2(self):
901            self._run('incidence',2)
902        def testincidence3(self):
903            M = self._run('incidence',3)
904    
905        def testincidence4(self):
906            self._run('incidence',4)
907        def testincidencefail5(self):
908            self._runfail('incidence',5)
909    
910        def testwritematrix(self):
911            self.L.load('test/ida/writematrix.a4c')
912            T = self.L.findType('writematrix')
913          M = T.getSimulation('sim')          M = T.getSimulation('sim')
914          M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())            M.build()
915          I = ascpy.Integrator(M)          I = ascpy.Integrator(M)
916          I.setEngine('IDA')          I.setEngine('IDA')
917            I.analyse()
918            F = os.tmpfile()
919            I.writeMatrix(F,"dF/dy")
920            F.seek(0)
921            print F.read()
922            F1 = os.tmpfile()
923            I.writeMatrix(F1,"dF/dy'")
924            F1.seek(0)
925            print F1.read()
926            F1 = os.tmpfile()
927            I.writeMatrix(F1,"dg/dx")
928            F1.seek(0)
929            print F1.read()
930            # for the moment you'll have to check these results manually.
931    
932        def testwritematrix2(self):
933            self.L.load('test/ida/writematrix.a4c')
934            T = self.L.findType('writematrix2')
935            M = T.getSimulation('sim')
936            M.build()
937            I = ascpy.Integrator(M)
938            I.setEngine('IDA')
939            I.analyse()
940            F = os.tmpfile()
941            I.writeMatrix(F,"dF/dy")
942            F.seek(0)
943            print F.read()
944            F1 = os.tmpfile()
945            I.writeMatrix(F1,"dF/dy'")
946            F1.seek(0)
947            print F1.read()
948            F1 = os.tmpfile()
949            I.writeMatrix(F1,"dg/dx")
950            F1.seek(0)
951            print F1.read()
952            #F1 = os.tmpfile()
953            #I.writeMatrix(F1,"dydp/dyd")
954            #F1.seek(0)
955            #print F1.read()
956            # for the moment you'll have to check these results manually.
957    
958        def testindexproblem(self):
959            self.L.load('test/ida/indexproblem.a4c')
960            T = self.L.findType('indexproblem')
961            M = T.getSimulation('sim')
962            M.build()
963            I = ascpy.Integrator(M)
964            I.setEngine('IDA')
965            I.analyse()
966            pass
967    
968        def testindexproblem2(self):
969            self.L.load('test/ida/indexproblem.a4c')
970            T = self.L.findType('indexproblem2')
971            M = T.getSimulation('sim')
972            M.build()
973            I = ascpy.Integrator(M)
974            I.setEngine('IDA')
975            try:
976                I.analyse()
977            except Exception,e:
978                return
979            self.fail("Index problem not detected")
980    
981        def testboundaries(self):
982            self.L.load('test/ida/boundaries.a4c')
983            T = self.L.findType('boundaries')
984            M = T.getSimulation('sim')
985            M.build()
986            I = ascpy.Integrator(M)
987            I.setEngine('IDA')
988            I.analyse()
989            I.setLogTimesteps(ascpy.Units("s"), 0.1, 20, 20)
990          I.setParameter('linsolver','DENSE')          I.setParameter('linsolver','DENSE')
991          I.setParameter('safeeval',True)          I.setParameter('calcic','Y')
992          I.setParameter('rtol',1e-8)          I.setParameter('linsolver','DENSE')
993          I.setMaxSubStep(0.001)          I.setParameter('safeeval',False)
         I.setMaxSubSteps(10000)  
           
994          I.setReporter(ascpy.IntegratorReporterConsole(I))          I.setReporter(ascpy.IntegratorReporterConsole(I))
         I.setLinearTimesteps(ascpy.Units("s"), 0, 2*float(M.v)/float(M.g), 2)  
         I.analyse()  
995          I.solve()          I.solve()
         print "At end of simulation,"  
         print "x = %f" % M.x  
         print "v = %f" % M.v  
         M.run(T.getMethod('self_test'))  
996    
997      def testlotkaDENSE(self):  # doesn't work yet:
998    #   def testincidence5(self):
999    #       self._run('incidence',5)
1000    
1001    
1002    #-------------------------------------------------------------------------------
1003    # Testing of IDA models using DENSE linear solver
1004    
1005    class TestIDADENSE(Ascend):
1006        """IDA DAE integrator, DENSE linear solver"""
1007    
1008        def testlotka(self):
1009          self.L.load('johnpye/lotka.a4c')          self.L.load('johnpye/lotka.a4c')
1010          M = self.L.findType('lotka').getSimulation('sim')          M = self.L.findType('lotka').getSimulation('sim')
1011          M.setSolver(ascpy.Solver("QRSlv"))          M.setSolver(ascpy.Solver("QRSlv"))
# Line 307  class TestIDADENSE(Ascend): Line 1024  class TestIDADENSE(Ascend):
1024          assert abs(M.F - 21.36) < 0.1          assert abs(M.F - 21.36) < 0.1
1025                    
1026      def testdenx(self):      def testdenx(self):
1027            print "-----------------------------====="
1028          self.L.load('johnpye/idadenx.a4c')          self.L.load('johnpye/idadenx.a4c')
1029          M = self.L.findType('idadenx').getSimulation('sim')          M = self.L.findType('idadenx').getSimulation('sim')
1030          M.setSolver(ascpy.Solver("QRSlv"))          M.setSolver(ascpy.Solver("QRSlv"))
1031          I = ascpy.Integrator(M)          I = ascpy.Integrator(M)
1032          I.setEngine('IDA')          I.setEngine('IDA')
1033          I.setParameter('calcic','NONE')          I.setParameter('calcic','YA_YDP')
1034          I.setParameter('linsolver','DENSE')          I.setParameter('linsolver','DENSE')
1035            I.setParameter('safeeval',True)
1036          I.setReporter(ascpy.IntegratorReporterConsole(I))          I.setReporter(ascpy.IntegratorReporterConsole(I))
1037          I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11)          I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11)
1038          I.setMaxSubStep(0);          I.setMaxSubStep(0);
1039          I.setInitialSubStep(0)          I.setInitialSubStep(0)
1040          I.setMaxSubSteps(0);          I.setMaxSubSteps(0)
1041          I.setParameter('autodiff',True)          I.setParameter('autodiff',True)
1042          I.analyse()          I.analyse()
1043          I.solve()          I.solve()
1044          assert abs(float(M.y1) - 5.1091e-08) < 1e-10          assert abs(float(M.y1) - 5.1091e-08) < 2e-9
1045          assert abs(float(M.y2) - 2.0437e-13) < 1e-15          assert abs(float(M.y2) - 2.0437e-13) < 2e-14
1046          assert abs(float(M.y3) - 1.0) < 1e-5          assert abs(float(M.y3) - 1.0) < 1e-5
1047    
1048      def testkryxDENSE(self):      def testhires(self):
1049          self.L.load('johnpye/idakryx.a4c')          self.L.load('test/hires.a4c')
1050          M = self.L.findType('idakryx').getSimulation('sim')          T = self.L.findType('hires')
1051            M = T.getSimulation('sim')
1052          M.setSolver(ascpy.Solver('QRSlv'))          M.setSolver(ascpy.Solver('QRSlv'))
         M.build()  
1053          I = ascpy.Integrator(M)          I = ascpy.Integrator(M)
1054          I.setEngine('IDA')          I.setEngine('IDA')
1055            I.setParameter('linsolver','DENSE')
1056            I.setParameter('rtol',1.1e-15)
1057            I.setParameter('atolvect',0)
1058            I.setParameter('atol',1.1e-15)
1059          I.setReporter(ascpy.IntegratorReporterConsole(I))          I.setReporter(ascpy.IntegratorReporterConsole(I))
1060            I.setLogTimesteps(ascpy.Units(""), 1, 321.8122, 5)
1061            I.setInitialSubStep(1e-5)
1062            I.setMaxSubSteps(10000)
1063            I.analyse()
1064            I.solve()
1065            for i in range(8):
1066                print "y[%d] = %.20g" % (i+1, M.y[i+1])
1067            M.run(T.getMethod('self_test'))
1068    
1069        def testchemakzo(self):
1070            self.L.load('test/chemakzo.a4c')
1071            T = self.L.findType('chemakzo')
1072            M = T.getSimulation('sim')
1073            M.setSolver(ascpy.Solver('QRSlv'))
1074            I = ascpy.Integrator(M)
1075            I.setEngine('IDA')
1076          I.setParameter('linsolver','DENSE')          I.setParameter('linsolver','DENSE')
1077          I.setParameter('maxl',8)          I.setParameter('rtol',1e-15)
1078          I.setParameter('gsmodified',False)          I.setParameter('atolvect',0)
1079          I.setParameter('autodiff',True)          I.setParameter('atol',1e-15)
1080          I.setParameter('rtol',0)          I.setReporter(ascpy.IntegratorReporterConsole(I))
1081          I.setParameter('atol',1e-3);          I.setLinearTimesteps(ascpy.Units("s"), 1, 180, 5)
1082          I.setParameter('atolvect',False)          I.setInitialSubStep(1e-13)
1083          I.setParameter('calcic','YA_YDP')          I.setMaxSubSteps(10000)
1084            I.analyse()
1085            I.solve()
1086            for i in range(6):
1087                print "y[%d] = %.20g" % (i+1, M.y[i+1])
1088            M.run(T.getMethod('self_test'))
1089    
1090        def testtransamp(self):
1091            self.L.load('test/transamp.a4c')
1092            T = self.L.findType('transamp')
1093            M = T.getSimulation('sim')
1094            M.setSolver(ascpy.Solver('QRSlv'))
1095            I = ascpy.Integrator(M)
1096            I.setEngine('IDA')
1097            I.setParameter('linsolver','DENSE')
1098            I.setParameter('rtol',1e-7)
1099            I.setParameter('atolvect',0)
1100            I.setParameter('atol',1e-7)
1101            I.setReporter(ascpy.IntegratorReporterConsole(I))
1102            I.setLinearTimesteps(ascpy.Units("s"), 0.05, 0.2, 20)
1103            I.setInitialSubStep(0.00001)
1104            I.setMaxSubSteps(10000)
1105          I.analyse()          I.analyse()
         I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 11)  
1106          I.solve()          I.solve()
1107          assert abs(M.u[2][2].getValue()) < 1e-5          for i in range(6):
1108                print "y[%d] = %.20g" % (i+1, M.y[i+1])
1109            M.run(T.getMethod('self_test'))
1110    
1111    # MODEL FAILS ANALYSIS: we need to add support for non-incident differential vars
1112    #   def testpollution(self):
1113    #       self.L.load('test/pollution.a4c')
1114    #       T = self.L.findType('pollution')
1115    #       M = T.getSimulation('sim')
1116    #       M.setSolver(ascpy.Solver('QRSlv'))
1117    #       I = ascpy.Integrator(M)
1118    #       I.setEngine('IDA')
1119    #       I.setParameter('linsolver','DENSE')
1120    #       I.setParameter('rtol',1.1e-15)
1121    #       I.setParameter('atolvect',0)
1122    #       I.setParameter('atol',1.1e-15)
1123    #       I.setReporter(ascpy.IntegratorReporterConsole(I))
1124    #       I.setLogTimesteps(ascpy.Units("s"), 1, 60, 5)
1125    #       I.setInitialSubStep(1e-5)
1126    #       I.setMaxSubSteps(10000)
1127    #       I.analyse()
1128    #       I.solve()
1129    #       for i in range(20):
1130    #           print "y[%d] = %.20g" % (i+1, M.y[i+1])
1131    #       M.run(T.getMethod('self_test'))
1132    
1133    ## @TODO fails during IDACalcIC (model too big?)
1134    #   def testkryx(self):
1135    #       self.L.load('johnpye/idakryx.a4c')
1136    #       ascpy.getCompiler().setUseRelationSharing(False)
1137    #       M = self.L.findType('idakryx').getSimulation('sim')
1138    #       M.setSolver(ascpy.Solver('QRSlv'))
1139    #       M.build()
1140    #       I = ascpy.Integrator(M)
1141    #       I.setEngine('IDA')
1142    #       I.setReporter(ascpy.IntegratorReporterConsole(I))
1143    #       I.setParameter('linsolver','DENSE')
1144    #       I.setParameter('maxl',8)
1145    #       I.setParameter('gsmodified',False)
1146    #       I.setParameter('autodiff',True)
1147    #       I.setParameter('rtol',0)
1148    #       I.setParameter('atol',1e-3);
1149    #       I.setParameter('atolvect',False)
1150    #       I.setParameter('calcic','YA_YDP')
1151    #       I.analyse()
1152    #       I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 11)
1153    #       I.solve()
1154    #       assert abs(M.u[2][2].getValue()) < 1e-5
1155            
1156  #-------------------------------------------------------------------------------  #-------------------------------------------------------------------------------
1157  # Testing of IDA models using SPGMR linear solver (Krylov)  # Testing of IDA models using SPGMR linear solver (Krylov)
# Line 436  class NotToBeTested: Line 1242  class NotToBeTested:
1242      def nothing(self):      def nothing(self):
1243          pass          pass
1244    
1245        def testnewton(self):
1246            sys.stderr.write("STARTING TESTNEWTON\n")
1247            self.L.load('johnpye/newton.a4c')
1248            T = self.L.findType('newton')
1249            M = T.getSimulation('sim')
1250            M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())  
1251            I = ascpy.Integrator(M)
1252            I.setEngine('IDA')
1253            I.setParameter('linsolver','DENSE')
1254            I.setParameter('safeeval',True)
1255            I.setParameter('rtol',1e-8)
1256            I.setMaxSubStep(0.001)
1257            I.setMaxSubSteps(10000)
1258            
1259            I.setReporter(ascpy.IntegratorReporterConsole(I))
1260            I.setLinearTimesteps(ascpy.Units("s"), 0, 2*float(M.v)/float(M.g), 2)
1261            I.analyse()
1262            I.solve()
1263            print "At end of simulation,"
1264            print "x = %f" % M.x
1265            print "v = %f" % M.v
1266            M.run(T.getMethod('self_test'))
1267    
1268  if __name__=='__main__':  if __name__=='__main__':
1269        # a whole bag of tricks to make sure we get the necessary dirs in our ascend, python and ld path vars
1270        restart = 0
1271    
1272        if platform.system()=="Windows":
1273            LD_LIBRARY_PATH="PATH"
1274            SEP = ";"
1275        else:
1276            LD_LIBRARY_PATH="LD_LIBRARY_PATH"
1277            SEP = ":"
1278    
1279        freesteamdir = os.path.expanduser("~/freesteam/ascend")
1280        modeldirs = [os.path.abspath(os.path.join(sys.path[0],"models")),os.path.abspath(freesteamdir)]
1281        if not os.environ.get('ASCENDLIBRARY'):
1282            os.environ['ASCENDLIBRARY'] = SEP.join(modeldirs)
1283            restart = 1
1284        else:
1285            envmodelsdir = [os.path.abspath(i) for i in os.environ['ASCENDLIBRARY'].split(SEP)]
1286            for l in modeldirs:
1287                if l in envmodelsdir[len(modeldirs):]:
1288                    envmodelsdir.remove(l)
1289                    restart = 1
1290            for l in modeldirs:
1291                if l not in envmodelsdir:
1292                    envmodelsdir.insert(0,l)
1293                    restart = 1
1294            os.environ['ASCENDLIBRARY'] = SEP.join(envmodelsdir)    
1295    
1296        libdirs = ["pygtk","."]
1297        libdirs = [os.path.normpath(os.path.join(sys.path[0],l)) for l in libdirs]
1298        if not os.environ.get(LD_LIBRARY_PATH):
1299            os.environ[LD_LIBRARY_PATH]=SEP.join(libdirs)
1300            restart = 1
1301        else:
1302            envlibdirs = [os.path.normpath(i) for i in os.environ[LD_LIBRARY_PATH].split(SEP)]
1303            for l in libdirs:
1304                if l in envlibdirs[len(libdirs):]:
1305                    envlibdirs.remove(l)
1306                    restart = 1
1307            for l in libdirs:
1308                if l not in envlibdirs:
1309                    envlibdirs.insert(0,l)
1310                    restart = 1    
1311            os.environ[LD_LIBRARY_PATH] = SEP.join(envlibdirs)
1312    
1313        pypath = os.path.normpath(os.path.join(sys.path[0],"pygtk"))
1314        if not os.environ.get('PYTHONPATH'):
1315            os.environ['PYTHONPATH']=pypath
1316        else:
1317            envpypath = os.environ['PYTHONPATH'].split(SEP)
1318            if pypath not in envpypath:
1319                envpypath.insert(0,pypath)
1320                os.environ['PYTHONPATH']=SEP.join(envpypath)
1321                restart = 1
1322    
1323        if restart:
1324            script = os.path.join(sys.path[0],"test.py")                    
1325            print "Restarting with..."
1326            print "  export LD_LIBRARY_PATH=%s" % os.environ.get(LD_LIBRARY_PATH)
1327            print "  export PYTHONPATH=%s" % os.environ.get('PYTHONPATH')
1328            print "  export ASCENDLIBRARY=%s" % os.environ.get('ASCENDLIBRARY')
1329    
1330            os.execvp("python",[script] + sys.argv)
1331    
1332        import ascpy
1333    
1334        try:
1335            import cunit
1336        except:
1337            pass
1338    
1339      atexit.register(ascpy.shutdown)      atexit.register(ascpy.shutdown)
1340      #suite = unittest.TestSuite()      #suite = unittest.TestSuite()
1341      #suite = unittest.defaultTestLoader.loadTestsFromName('__main__')      #suite = unittest.defaultTestLoader.loadTestsFromName('__main__')

Legend:
Removed from v.1021  
changed lines
  Added in v.1339

john.pye@anu.edu.au
ViewVC Help
Powered by ViewVC 1.1.22