1 |
#!/usr/bin/env python |
2 |
import unittest |
3 |
|
4 |
import platform, sys |
5 |
if platform.system() != "Windows": |
6 |
import dl |
7 |
sys.setdlopenflags(dl.RTLD_GLOBAL|dl.RTLD_NOW) |
8 |
|
9 |
import ascpy |
10 |
import math |
11 |
import os, subprocess |
12 |
import atexit |
13 |
import cunit |
14 |
|
15 |
class Ascend(unittest.TestCase): |
16 |
|
17 |
def setUp(self): |
18 |
import ascpy |
19 |
self.L = ascpy.Library() |
20 |
|
21 |
def tearDown(self): |
22 |
self.L.clear() |
23 |
del self.L |
24 |
|
25 |
class AscendSelfTester(Ascend): |
26 |
|
27 |
def _run(self,modelname,solvername="QRSlv",filename=None): |
28 |
if filename==None: |
29 |
filename = 'johnpye/%s.a4c' % modelname |
30 |
self.L.load(filename) |
31 |
T = self.L.findType(modelname) |
32 |
M = T.getSimulation('sim') |
33 |
M.build() |
34 |
M.solve(ascpy.Solver(solvername),ascpy.SolverReporter()) |
35 |
M.run(T.getMethod('self_test')) |
36 |
return M |
37 |
|
38 |
class TestCompiler(Ascend): |
39 |
|
40 |
def testloading(self): |
41 |
pass |
42 |
|
43 |
def testsystema4l(self): |
44 |
self.L.load('system.a4l') |
45 |
|
46 |
def testatomsa4l(self): |
47 |
self.L.load('atoms.a4l') |
48 |
|
49 |
class TestSolver(AscendSelfTester): |
50 |
|
51 |
def testlog10(self): |
52 |
self._run('testlog10') |
53 |
|
54 |
def testconopt(self): |
55 |
self._run('testconopt',"CONOPT") |
56 |
|
57 |
def testcmslv2(self): |
58 |
self._run('testcmslv2',"CMSlv") |
59 |
|
60 |
def testsunpos1(self): |
61 |
self._run('example_1_6_1',"QRSlv","johnpye/sunpos.a4c") |
62 |
|
63 |
def testsunpos2(self): |
64 |
self._run('example_1_6_2',"QRSlv","johnpye/sunpos.a4c") |
65 |
|
66 |
def testsunpos3(self): |
67 |
self._run('example_1_7_1',"QRSlv","johnpye/sunpos.a4c") |
68 |
|
69 |
def testsunpos4(self): |
70 |
self._run('example_1_7_2',"QRSlv","johnpye/sunpos.a4c") |
71 |
|
72 |
def testsunpos5(self): |
73 |
self._run('example_1_7_3',"QRSlv","johnpye/sunpos.a4c") |
74 |
|
75 |
def testsunpos6(self): |
76 |
self._run('example_1_8_1',"QRSlv","johnpye/sunpos.a4c") |
77 |
|
78 |
class TestIntegrator(Ascend): |
79 |
|
80 |
def testListIntegrators(self): |
81 |
I = ascpy.Integrator.getEngines() |
82 |
s1 = sorted([str(i) for i in I.values()]) |
83 |
s2 = sorted(['IDA','LSODE','AWW']) |
84 |
assert s1==s2 |
85 |
|
86 |
# this routine is reused by both testIDA and testLSODE |
87 |
def _testIntegrator(self,integratorname): |
88 |
self.L.load('johnpye/shm.a4c') |
89 |
M = self.L.findType('shm').getSimulation('sim') |
90 |
M.setSolver(ascpy.Solver('QRSlv')) |
91 |
print M.getChildren() |
92 |
assert float(M.x) == 10.0 |
93 |
assert float(M.v) == 0.0 |
94 |
t_end = math.pi |
95 |
|
96 |
I = ascpy.Integrator(M) |
97 |
I.setReporter(ascpy.IntegratorReporterNull(I)) |
98 |
I.setEngine(integratorname); |
99 |
I.setLinearTimesteps(ascpy.Units("s"), 0.0, t_end, 100); |
100 |
I.setMinSubStep(0.0005); # these limits are required by IDA at present (numeric diff) |
101 |
I.setMaxSubStep(0.02); |
102 |
I.setInitialSubStep(0.001); |
103 |
I.setMaxSubSteps(200); |
104 |
if(integratorname=='IDA'): |
105 |
I.setParameter('autodiff',False) |
106 |
I.analyse(); |
107 |
I.solve(); |
108 |
print "At end of simulation," |
109 |
print "x = %f" % M.x |
110 |
print "v = %f" % M.v |
111 |
assert abs(float(M.x) + 10) < 1e-2 |
112 |
assert abs(float(M.v)) < 1e-2 |
113 |
assert I.getNumObservedVars() == 3 |
114 |
|
115 |
def testInvalidIntegrator(self): |
116 |
self.L.load('johnpye/shm.a4c') |
117 |
M = self.L.findType('shm').getSimulation('sim') |
118 |
M.setSolver(ascpy.Solver('QRSlv')) |
119 |
I = ascpy.Integrator(M) |
120 |
try: |
121 |
I.setEngine('___NONEXISTENT____') |
122 |
except RuntimeError: |
123 |
return |
124 |
self.fail("setEngine did not raise error!") |
125 |
|
126 |
def testLSODE(self): |
127 |
self._testIntegrator('LSODE') |
128 |
|
129 |
def testIDA(self): |
130 |
self._testIntegrator('IDA') |
131 |
|
132 |
def testparameters(self): |
133 |
self.L.load('johnpye/shm.a4c') |
134 |
M = self.L.findType('shm').getSimulation('sim') |
135 |
M.build() |
136 |
I = ascpy.Integrator(M) |
137 |
I.setEngine('IDA') |
138 |
P = I.getParameters() |
139 |
for p in P: |
140 |
print p.getName(),"=",p.getValue() |
141 |
assert len(P)==11 |
142 |
assert P[0].isStr() |
143 |
assert P[0].getName()=="linsolver" |
144 |
assert P[0].getValue()=='SPGMR' |
145 |
assert P[2].getName()=="autodiff" |
146 |
assert P[2].getValue()==True |
147 |
assert P[7].getName()=="atolvect" |
148 |
assert P[7].getBoolValue() == True |
149 |
P[2].setBoolValue(False) |
150 |
assert P[2].getBoolValue()==False |
151 |
I.setParameters(P) |
152 |
assert I.getParameterValue('autodiff')==False |
153 |
I.setParameter('autodiff',True) |
154 |
try: |
155 |
v = I.getParameterValue('nonexist') |
156 |
except KeyError: |
157 |
pass |
158 |
else: |
159 |
self.fail('Failed to trip invalid Integrator parameter') |
160 |
|
161 |
class TestLSODE(Ascend): |
162 |
|
163 |
def testzill(self): |
164 |
self.L.load('johnpye/zill.a4c') |
165 |
T = self.L.findType('zill') |
166 |
M = T.getSimulation('sim') |
167 |
M.setSolver(ascpy.Solver('QRSlv')) |
168 |
I = ascpy.Integrator(M) |
169 |
I.setEngine('LSODE') |
170 |
I.setMinSubStep(1e-7) |
171 |
I.setMaxSubStep(0.001) |
172 |
I.setMaxSubSteps(10000) |
173 |
I.setReporter(ascpy.IntegratorReporterConsole(I)) |
174 |
I.setLinearTimesteps(ascpy.Units(), 1.0, 1.5, 5) |
175 |
I.analyse() |
176 |
I.solve() |
177 |
M.run(T.getMethod('self_test')) |
178 |
|
179 |
def testnewton(self): |
180 |
sys.stderr.write("STARTING TESTNEWTON\n") |
181 |
self.L.load('johnpye/newton.a4c') |
182 |
T = self.L.findType('newton') |
183 |
M = T.getSimulation('sim') |
184 |
M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter()) |
185 |
I = ascpy.Integrator(M) |
186 |
I.setEngine('LSODE') |
187 |
I.setParameter('rtolvect',False) |
188 |
I.setParameter('rtol',1e-7) |
189 |
I.setParameter('atolvect',False) |
190 |
I.setParameter('atol',1e-7) |
191 |
I.setMinSubStep(1e-7) |
192 |
I.setMaxSubStep(0.001) |
193 |
I.setMaxSubSteps(10000) |
194 |
|
195 |
I.setReporter(ascpy.IntegratorReporterConsole(I)) |
196 |
I.setLinearTimesteps(ascpy.Units("s"), 0, 2*float(M.v)/float(M.g), 2) |
197 |
I.analyse() |
198 |
I.solve() |
199 |
print "At end of simulation," |
200 |
print "x = %f" % M.x |
201 |
print "v = %f" % M.v |
202 |
M.run(T.getMethod('self_test')) |
203 |
|
204 |
def testlotka(self): |
205 |
self.L.load('johnpye/lotka.a4c') |
206 |
M = self.L.findType('lotka').getSimulation('sim') |
207 |
M.setSolver(ascpy.Solver("QRSlv")) |
208 |
I = ascpy.Integrator(M) |
209 |
I.setEngine('LSODE') |
210 |
I.setReporter(ascpy.IntegratorReporterConsole(I)) |
211 |
I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 5) |
212 |
I.analyse() |
213 |
print "Number of vars = %d" % I.getNumVars() |
214 |
assert I.getNumVars()==2 |
215 |
I.solve() |
216 |
assert I.getNumObservedVars() == 3; |
217 |
assert abs(M.R - 832) < 1.0 |
218 |
assert abs(M.F - 21.36) < 0.1 |
219 |
|
220 |
#------------------------------------------------------------------------------- |
221 |
# Testing of a external blackbox functions |
222 |
|
223 |
class TestBlackBox(AscendSelfTester): |
224 |
def testparsefail0(self): |
225 |
try: |
226 |
self.L.load('test/blackbox/parsefail0.a4c') |
227 |
self.fail("parsefail0 should not have loaded without errors") |
228 |
except: |
229 |
pass |
230 |
|
231 |
def testparsefail1(self): |
232 |
try: |
233 |
self.L.load('test/blackbox/parsefail1.a4c') |
234 |
self.fail("parsefail1 should not have loaded without errors") |
235 |
except: |
236 |
pass |
237 |
|
238 |
def testparsefail2(self): |
239 |
try: |
240 |
self.L.load('test/blackbox/parsefail2.a4c') |
241 |
self.fail("parsefail2 should not have loaded without errors") |
242 |
except: |
243 |
pass |
244 |
|
245 |
def testparsefail3(self): |
246 |
try: |
247 |
self.L.load('test/blackbox/parsefail3.a4c') |
248 |
self.fail("parsefail3 should not have loaded without errors") |
249 |
except: |
250 |
pass |
251 |
|
252 |
def testparsefail4(self): |
253 |
try: |
254 |
self.L.load('test/blackbox/parsefail4.a4c') |
255 |
self.fail("parsefail4 should not have loaded") |
256 |
except: |
257 |
pass |
258 |
|
259 |
def testfail1(self): |
260 |
"""Mismatched arg counts check-- tests bbox, not ascend.""" |
261 |
self.L.load('test/blackbox/fail1.a4c') |
262 |
M = self.L.findType('fail1').getSimulation('sim') |
263 |
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 |
|
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 |
class TestExtFn(AscendSelfTester): |
359 |
def testextfntest(self): |
360 |
M = self._run('extfntest',filename='johnpye/extfn/extfntest.a4c') |
361 |
self.assertAlmostEqual(M.y, 2); |
362 |
self.assertAlmostEqual(M.x, 1); |
363 |
self.assertAlmostEqual(M.y, M.x + 1); |
364 |
|
365 |
# 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 |
#------------------------------------------------------------------------------- |
380 |
# Testing of a ExtPy - external python methods |
381 |
|
382 |
class TestExtPy(AscendSelfTester): |
383 |
def testextpytest(self): |
384 |
print "-------------------=--=-=-=-" |
385 |
M = self._run('extpytest',filename='johnpye/extpy/extpytest.a4c') |
386 |
|
387 |
#------------------------------------------------------------------------------- |
388 |
# Testing of freesteam external steam properties functions |
389 |
|
390 |
with_freesteam = True |
391 |
try: |
392 |
import freesteam |
393 |
have_freesteam = True |
394 |
except ImportError,e: |
395 |
have_freesteam = False |
396 |
|
397 |
if with_freesteam and have_freesteam: |
398 |
class TestFreesteam(Ascend): |
399 |
def testload(self): |
400 |
self.L.load('johnpye/thermalequilibrium2.a4c') |
401 |
|
402 |
def testinstantiate(self): |
403 |
self.testload() |
404 |
M = self.L.findType('thermalequilibrium2').getSimulation('sim') |
405 |
|
406 |
def testsolve(self): |
407 |
self.testinstantiate() |
408 |
M.setSolver(ascpy.Solver("QRSlv")) |
409 |
#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 |
class TestIDADENSE(Ascend): |
428 |
"""IDA DAE integrator, DENSE linear solver""" |
429 |
|
430 |
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 |
I.setParameter('linsolver','DENSE') |
439 |
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 |
I.setLinearTimesteps(ascpy.Units("s"), 0, 2*float(M.v)/float(M.g), 2) |
446 |
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 |
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 |
assert I.getNumObservedVars() == 3 |
468 |
assert abs(M.R - 832) < 1.0 |
469 |
assert abs(M.F - 21.36) < 0.1 |
470 |
|
471 |
def testdenx(self): |
472 |
print "-----------------------------=====" |
473 |
self.L.load('johnpye/idadenx.a4c') |
474 |
M = self.L.findType('idadenx').getSimulation('sim') |
475 |
M.setSolver(ascpy.Solver("QRSlv")) |
476 |
I = ascpy.Integrator(M) |
477 |
I.setEngine('IDA') |
478 |
I.setParameter('calcic','YA_YPD') |
479 |
I.setParameter('linsolver','DENSE') |
480 |
I.setReporter(ascpy.IntegratorReporterConsole(I)) |
481 |
I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11) |
482 |
I.setMaxSubStep(0); |
483 |
I.setInitialSubStep(0) |
484 |
I.setMaxSubSteps(0); |
485 |
I.setParameter('autodiff',True) |
486 |
I.analyse() |
487 |
I.solve() |
488 |
assert abs(float(M.y1) - 5.1091e-08) < 2e-9 |
489 |
assert abs(float(M.y2) - 2.0437e-13) < 2e-14 |
490 |
assert abs(float(M.y3) - 1.0) < 1e-5 |
491 |
|
492 |
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 |
I.setParameter('calcic','YA_YDP') |
508 |
I.analyse() |
509 |
I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 11) |
510 |
I.solve() |
511 |
assert abs(M.u[2][2].getValue()) < 1e-5 |
512 |
|
513 |
#------------------------------------------------------------------------------- |
514 |
# Testing of IDA models using SPGMR linear solver (Krylov) |
515 |
|
516 |
# 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 |
I = ascpy.Integrator(M) |
523 |
I.setEngine('IDA') |
524 |
I.setReporter(ascpy.IntegratorReporterConsole(I)) |
525 |
I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 5) |
526 |
I.setParameter('rtol',1e-8) |
527 |
I.analyse() |
528 |
assert I.getNumVars()==2 |
529 |
assert abs(M.R - 1000) < 1e-300 |
530 |
I.solve() |
531 |
assert I.getNumObservedVars() == 3 |
532 |
assert abs(M.R - 832) < 1.0 |
533 |
assert abs(M.F - 21.36) < 0.1 |
534 |
|
535 |
|
536 |
def testkryx(self): |
537 |
self.L.load('johnpye/idakryx.a4c') |
538 |
M = self.L.findType('idakryx').getSimulation('sim') |
539 |
M.build() |
540 |
I = ascpy.Integrator(M) |
541 |
I.setEngine('IDA') |
542 |
I.setReporter(ascpy.IntegratorReporterConsole(I)) |
543 |
I.setParameter('linsolver','SPGMR') |
544 |
I.setParameter('prec','JACOBI') |
545 |
I.setParameter('maxl',8) |
546 |
I.setParameter('gsmodified',False) |
547 |
I.setParameter('autodiff',True) |
548 |
I.setParameter('gsmodified',True) |
549 |
I.setParameter('rtol',0) |
550 |
I.setParameter('atol',1e-3); |
551 |
I.setParameter('atolvect',False) |
552 |
I.setParameter('calcic','Y') |
553 |
I.analyse() |
554 |
I.setLogTimesteps(ascpy.Units("s"), 0.01, 10.24, 10); |
555 |
print M.udot[1][3] |
556 |
I.solve() |
557 |
assert 0 |
558 |
|
559 |
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 |
I.setLinearTimesteps(ascpy.Units(), 1.0, 1.5, 5) |
572 |
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 |
I.setLogTimesteps(ascpy.Units("s"), 0.4, 4e10, 11) |
584 |
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 |
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 |
|
597 |
# move code above down here if you want to temporarily avoid testing it |
598 |
class NotToBeTested: |
599 |
def nothing(self): |
600 |
pass |
601 |
|
602 |
if __name__=='__main__': |
603 |
atexit.register(ascpy.shutdown) |
604 |
#suite = unittest.TestSuite() |
605 |
#suite = unittest.defaultTestLoader.loadTestsFromName('__main__') |
606 |
#unittest.TextTestRunner(verbosity=2).run(suite) |
607 |
unittest.main() |