def check_inputs(self):
# set the timesteps (samples)
_val = {}
units = ''
for _k, _v in {
self.beginentry: [lambda x: float(x), "begin"],
self.durationentry: [lambda x: float(x), "duration"],
self.nstepsentry: [lambda x: int(x), "num"]
}.iteritems():
x = RealAtomEntry(self.indepvar.getInstance(), _k.get_text())
x.checkEntry()
if _k == self.beginentry:
units = x.units
#self.indepvar.getInstance().setRealValueWithUnits()
if _k == self.nstepsentry:
_val[_v[1]] = _v[0](_k.get_text())
else:
_val[_v[1]] = _v[0](x.getValue() /
ascpy.Units(units).getConversion())
self.integrator.setLinearTimesteps(ascpy.Units(units), _val["begin"],
(_val["begin"] + _val["duration"]),
_val["num"])
self.begin = _val["begin"]
self.duration = _val["duration"]
self.prefs.setStringPref("Integrator", "duration", str(self.duration))
# set substep parameters (ie settings common to any integrator engine)
_failed = False
x = {}
for _k, _v in self.settings.iteritems():
try:
_f = self.integratorentries[_k]
# pass the substep setting to the integrator
x[_f] = RealAtomEntry(self.indepvar.getInstance(),
_f.get_text())
x[_f].checkEntry()
if _k != "maxsteps":
self.taint_entry(_f, "white")
_v[1](x[_f].getValue() /
ascpy.Units(units).getConversion())
else:
_v[1](_f.get_text())
self.color_entry(_f, "white")
except ValueError, e:
if _k != "maxsteps":
self.taint_entry(_f, "#FFBBBB")
else:
self.color_entry(_f, "#FFBBBB")
_failed = True
def _testIntegrator(self,integratorname):
self.L.load('johnpye/shm.a4c')
M = self.L.findType('shm').getSimulation('sim',1)
M.setSolver(ascpy.Solver('QRSlv'))
P = M.getParameters()
M.setParameter('feastol',1e-12)
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.0001); # these limits are required by IDA at present (numeric diff)
I.setMaxSubStep(0.1);
I.setInitialSubStep(0.001);
I.setMaxSubSteps(200);
if(integratorname=='IDA'):
I.setParameter('autodiff',False)
for p in M.getParameters():
print p.getName(),"=",p.getValue()
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 checkEntry(self):
_instdim = self.instance.type.getDimensions()
_insttype = self.instance.type
try:
# match a float with option text afterwards, optionally separated by whitespace
_match = re.match(UNITS_RE, self.newtext)
if not _match:
raise InputError("Not a valid value-and-optional-units")
_val = _match.group(1) # the numerical part of the input
self.units = _match.group(5) # the text entered for units
#_val, _units = re.split("[ \t]+",newtext,2);
except RuntimeError:
raise InputError("Unable to split value and units")
print "val = ", _val
print "units = ", self.units
# parse the units, throw an error if no good
try:
_val = float(_val)
except RuntimeError:
raise InputError("Unable to convert number part '%s' to float" %
_val)
# check the units
if self.units.strip() == "":
# if no units entered, assume the 'preferred' units
_u = _insttype.getPreferredUnits()
if _u is None:
# no preferred units for this type, so assume default units
_u = _instdim.getDefaultUnits()
print "Assuming units '%s'" % _u.getName().toString()
else:
try:
_u = ascpy.Units(self.units)
print "Parsed units '%s'" % self.units
except RuntimeError:
raise InputError("Unrecognisable units '%s'" % self.units)
if _instdim != _u.getDimensions():
if _u.getDimensions().isDimensionless():
self.units = "[dimensionless]"
_my_dims = _instdim.getDefaultUnits()
if _instdim.isDimensionless():
_my_dims = "[dimensionless]"
raise InputError(
"Incompatible units '%s' (must fit with '%s')" %
(self.units, _my_dims.getName().toString()))
self._conv = float(_u.getConversion())
# self.reporter.reportNote("Converting: multiplying '%s %s' by factor %s to get SI units" % (_val, _units, _conv) )
self.value = _val
print "Setting '%s' to '%f'" % (
self.instance.type.getName().toString(), self.value)
def testpeturbida(self):
M = self.testdsgsat()
self.assertAlmostEqual(M.dTw_dt[2],0.0)
T = self.L.findType('dsgsat3')
M.run(T.getMethod('free_states'))
# here is the peturbation...
qdot_s = float(M.qdot_s)
print "OLD QDOT_S = %f" % qdot_s
M.qdot_s.setRealValueWithUnits(6000,"W/m")
# IDA has its own initial conditions solver, so no need to call QRSlv here
I = ascpy.Integrator(M)
I.setEngine('IDA')
I.setParameter('linsolver','DENSE')
I.setReporter(ascpy.IntegratorReporterConsole(I))
#I.setLinearTimesteps(ascpy.Units("s"), 0,300,300)
I.setLogTimesteps(ascpy.Units("s"), 0.009, 1200, 150)
I.analyse()
F = file('ga.mm','w')
I.writeMatrix(F,'dg/dz')
F = file('gd.mm','w')
I.writeMatrix(F,'dg/dx')
F = file('fa.mm','w')
I.writeMatrix(F,'df/dz')
F = file('fd.mm','w')
I.writeMatrix(F,'df/dx')
F = file('fdp.mm','w')
I.writeMatrix(F,"df/dx'")
I.solve()
def teststeadyida(self):
M = self.testdsgsat()
self.assertAlmostEqual(M.dTw_dt[2],0.0)
Tw1 = float(M.T_w[2])
T = self.L.findType('dsgsat3')
M.run(T.getMethod('free_states'))
I = ascpy.Integrator(M)
I.setEngine('IDA')
I.setParameter('linsolver','DENSE')
I.setParameter('safeeval',True)
I.setParameter('rtol',1e-4)
I.setParameter('atolvect',False)
I.setParameter('atol',1e-4)
I.setParameter('maxord',3)
I.setInitialSubStep(0.001)
I.setReporter(ascpy.IntegratorReporterConsole(I))
I.setLinearTimesteps(ascpy.Units("s"), 0, 3600, 10)
I.analyse()
I.solve()
self.assertAlmostEqual(float(M.T_w[2]),Tw1)
M.qdot_s.setRealValueWithUnits(1000,"W/m")
self.assertAlmostEqual(M.qdot_s.to("W/m"),1000)
M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
print "dTw/dt = %f" % M.dTw_dt[2]
self.assertNotAlmostEqual(M.dTw_dt[2],0.0)
F=file('dsgsat.dot','w')
M.write(F,'dot')
def teststeadylsode(self):
"test that steady conditions are stable with LSODE"
M = self.testdsgsat()
#M.qdot_s.setRealValueWithUnits(1000,"W/m")
M.solve(ascpy.Solver('QRSlv'),ascpy.SolverReporter())
#M.setParameter('
I = ascpy.Integrator(M)
I.setEngine('LSODE')
I.setReporter(ascpy.IntegratorReporterConsole(I))
I.setLinearTimesteps(ascpy.Units("s"), 0, 3600, 10)
I.analyse()
I.solve()
def testlotka(self):
self.L.load('test/dopri5/dopri5test.a4c')
M = self.L.findType('dopri5test').getSimulation('sim')
M.setSolver(ascpy.Solver("QRSlv"))
M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())
I = ascpy.Integrator(M)
I.setEngine('DOPRI5')
I.setReporter(ascpy.IntegratorReporterConsole(I))
I.setLinearTimesteps(ascpy.Units("s"), 0, 200, 20)
I.setParameter('rtol',1e-8)
I.analyse()
assert I.getNumVars()==1
I.solve()
def testlotka(self):
self.L.load('johnpye/lotka.a4c')
M = self.L.findType('lotka').getSimulation('sim',1)
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
def testboundaries(self):
self.L.load('test/ida/boundaries.a4c')
T = self.L.findType('boundaries')
M = T.getSimulation('sim')
M.build()
I = ascpy.Integrator(M)
I.setEngine('IDA')
I.analyse()
I.setLogTimesteps(ascpy.Units("s"), 0.1, 20, 20)
I.setParameter('linsolver','DENSE')
I.setParameter('calcic','Y')
I.setParameter('linsolver','DENSE')
I.setParameter('safeeval',False)
I.setReporter(ascpy.IntegratorReporterConsole(I))
I.solve()
def testzill(self):
self.L.load('johnpye/zill.a4c')
T = self.L.findType('zill')
M = T.getSimulation('sim',1)
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 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 testhires(self):
self.L.load('test/hires.a4c')
T = self.L.findType('hires')
M = T.getSimulation('sim')
M.setSolver(ascpy.Solver('QRSlv'))
I = ascpy.Integrator(M)
I.setEngine('IDA')
I.setParameter('linsolver','DENSE')
I.setParameter('rtol',1.1e-15)
I.setParameter('atolvect',0)
I.setParameter('atol',1.1e-15)
I.setReporter(ascpy.IntegratorReporterConsole(I))
I.setLogTimesteps(ascpy.Units(""), 1, 321.8122, 5)
I.setInitialSubStep(1e-5)
I.setMaxSubSteps(10000)
I.analyse()
I.solve()
for i in range(8):
print "y[%d] = %.20g" % (i+1, M.y[i+1])
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
def testtransamp(self):
self.L.load('test/transamp.a4c')
T = self.L.findType('transamp')
M = T.getSimulation('sim')
M.setSolver(ascpy.Solver('QRSlv'))
I = ascpy.Integrator(M)
I.setEngine('IDA')
I.setParameter('linsolver','DENSE')
I.setParameter('rtol',1e-7)
I.setParameter('atolvect',0)
I.setParameter('atol',1e-7)
I.setReporter(ascpy.IntegratorReporterConsole(I))
I.setLinearTimesteps(ascpy.Units("s"), 0.05, 0.2, 20)
I.setInitialSubStep(0.00001)
I.setMaxSubSteps(10000)
I.analyse()
I.solve()
for i in range(6):
print "y[%d] = %.20g" % (i+1, M.y[i+1])
M.run(T.getMethod('self_test'))
def testaren(self):
self.L.load('test/dopri5/aren.a4c')
M = self.L.findType('aren').getSimulation('sim')
M.setSolver(ascpy.Solver("QRSlv"))
M.solve(ascpy.Solver("QRSlv"),ascpy.SolverReporter())
I = ascpy.Integrator(M)
I.setEngine('DOPRI5')
I.setReporter(ascpy.IntegratorReporterConsole(I))
#xend = 17.0652165601579625588917206249
I.setLinearTimesteps(ascpy.Units("s"), 0, 17.0652165601579625588917206249, 10)
I.setParameter('rtol',1e-7)
I.setParameter('atol',1e-7)
I.setParameter('tolvect',False)
I.setMinSubStep(0);
I.setMaxSubStep(0);
I.setInitialSubStep(0);
I.analyse()
I.solve()
print "y[0] = %f" % float(M.y[0])
assert abs(float(M.y[0]) - 0.994) < 1e-5
assert abs(float(M.y[1]) - 0.0) < 1e-5
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_YDP')
I.setParameter('linsolver','DENSE')
I.setParameter('safeeval',True)
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 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 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 testintegrate(self):
"""integrate transfer of heat from one mass of water/steam to another
according to Newton's law of cooling"""
M = 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(1)
I.analyse()
print "Number of vars = %d" % I.getNumVars()
assert I.getNumVars()==2
I.solve()
assert I.getNumObservedVars() == 3;
print "S[1].T = %f K" % M.S[1].T
print "S[2].T = %f K" % M.S[2].T
print "Q = %f W" % M.Q
self.assertAlmostEqual(float(M.S[1].T),506.77225109,4);
self.assertAlmostEqual(float(M.S[2].T),511.605173967,5);
self.assertAlmostEqual(float(M.Q),-48.32922877329,3);
self.assertAlmostEqual(float(M.t),3000);
print "Note that the above values have not been verified analytically"
import matplotlib.pyplot as plt
## CODE BEGINS
lib = ascpy.Library()
lib.load('test/ida/leon/bouncingball.a4c')
M = lib.findType('bouncingball').getSimulation('sim')
M.setSolver(ascpy.Solver('QRSlv'))
P = M.getParameters()
I = ascpy.Integrator(M)
I.setEngine('IDA')
I.setLinearTimesteps(ascpy.Units("s"), 0.0, 23, 300)
I.setMinSubStep(0.1)
I.setMaxSubStep(1)
I.setInitialSubStep(0.001)
I.setMaxSubSteps(400)
I.setParameter('autodiff', False)
I.analyse()
reporter = TReport.TestReporter(I)
I.setReporter(reporter)
I.solve()
fig = plt.figure()
data = reporter.data
plt.plot(reporter.t, data)
plt.show()
if _k != "maxsteps":
self.taint_entry(_f, "#FFBBBB")
else:
self.color_entry(_f, "#FFBBBB")
_failed = True
if _failed:
raise IntegratorError("Invalid step parameter(s)")
for _k, _v in self.settings.iteritems():
# store those inputs for next time
_f = self.integratorentries[_k]
if _k != "maxsteps":
self.prefs.setStringPref(
"Integrator", _k,
str(x[_f].getValue() / ascpy.Units(units).getConversion()))
else:
self.prefs.setStringPref("Integrator", _k, str(_f.get_text()))
# set engine (and check that it's OK with this system)
engine = self.engineselect.get_active()
if engine == -1:
self.color_entry(self.engineselect, "#FFBBBB")
raise IntegratorError("No engine selected")
self.color_entry(self.engineselect, "white")
try:
self.prefs.setStringPref("Integrator", "engine",
self.engines[engine])
_res = self.integrator.setEngine(self.engines[engine])
import matplotlib.pyplot as plt
## CODE BEGINS
lib = ascpy.Library()
lib.load('test/ida/leon/electron.a4c')
M = lib.findType('electron').getSimulation('sim')
M.setSolver(ascpy.Solver('QRSlv'))
P = M.getParameters()
I = ascpy.Integrator(M)
I.setEngine('IDA')
I.setLinearTimesteps(ascpy.Units("s"), 0.0, 40.0, 60)
I.setMinSubStep(0.0001)
I.setMaxSubStep(0.1)
I.setInitialSubStep(0.001)
I.setMaxSubSteps(200)
I.setParameter('autodiff', False)
I.analyse()
reporter = TReport.TestReporter(I)
I.setReporter(reporter)
I.solve()
x1 = []
x2 = []
data = reporter.data
for i in range(len(data)):
# here is the peturbation...
print "CREATING PETURBATION..."
M.qdot_s.setRealValueWithUnits(6000, "W/m")
# IDA has its own initial conditions solver, so no need to call QRSlv here
I = ascpy.Integrator(M)
I.setEngine('IDA')
I.setParameter('linsolver', 'DENSE')
I.setParameter('safeeval', True)
I.setParameter('rtol', 1e-4)
I.setParameter('atolvect', False)
I.setParameter('atol', 1e-4)
I.setParameter('maxord', 2)
I.setParameter('calcic', 'YA_YDP')
I.setInitialSubStep(0.001)
I.setReporter(ascpy.IntegratorReporterConsole(I))
I.setLogTimesteps(ascpy.Units("s"), 0.001, 0.002, 10)
I.analyse()
F = file('gz.mm', 'w')
I.writeMatrix(F, 'dg/dz')
F = file('gx.mm', 'w')
I.writeMatrix(F, 'dg/dx')
F = file('fz.mm', 'w')
I.writeMatrix(F, 'df/dz')
F = file('fx.mm', 'w')
I.writeMatrix(F, 'df/dx')
F = file('fxp.mm', 'w')
I.writeMatrix(F, "df/dx'")
#I.solve()
from scipy import io
from scipy import linalg
