def test_problem_name_attribute(self):
rhs = lambda t, y: y
prob = Explicit_Problem(rhs, 0.0)
assert prob.name == "---"
prob = Explicit_Problem(rhs, 0.0, name="Test")
assert prob.name == "Test"
def setUp(self):
"""
This sets up the test case.
"""
def f(t,y):
eps = 1.e-6
my = 1./eps
yd_0 = y[1]
yd_1 = my*((1.-y[0]**2)*y[1]-y[0])
return N.array([yd_0,yd_1])
def jac(t,y):
eps = 1.e-6
my = 1./eps
J = N.zeros([2,2])
J[0,0]=0.
J[0,1]=1.
J[1,0]=my*(-2.*y[0]*y[1]-1.)
J[1,1]=my*(1.-y[0]**2)
return J
def jac_sparse(t,y):
eps = 1.e-6
my = 1./eps
J = N.zeros([2,2])
J[0,0]=0.
J[0,1]=1.
J[1,0]=my*(-2.*y[0]*y[1]-1.)
J[1,1]=my*(1.-y[0]**2)
return sp.csc_matrix(J)
#Define an Assimulo problem
y0 = [2.0,-0.6] #Initial conditions
exp_mod = Explicit_Problem(f,y0)
exp_mod_t0 = Explicit_Problem(f,y0,1.0)
exp_mod_sp = Explicit_Problem(f,y0)
exp_mod.jac = jac
exp_mod_sp.jac = jac_sparse
self.mod = exp_mod
#Define an explicit solver
self.sim = Radau5ODE(exp_mod) #Create a Radau5 solve
self.sim_t0 = Radau5ODE(exp_mod_t0)
self.sim_sp = Radau5ODE(exp_mod_sp)
#Sets the parameters
self.sim.atol = 1e-4 #Default 1e-6
self.sim.rtol = 1e-4 #Default 1e-6
self.sim.inith = 1.e-4 #Initial step-size
self.sim.usejac = False
def simulate(self, Tend, nIntervals, gridWidth):
problem = Explicit_Problem(self.rhs, self.y0)
problem.name = 'RK34'
problem.handle_result = self.handle_result
problem.handle_event = self.handle_event
problem.time_events = self.time_events
problem.finalize = self.finalize
if hasattr(self, 'state_events'):
print 'Warning: state_event function in RK34 is not supported and will be ignored!'
simulation = RungeKutta34(problem)
# Sets additional parameters
simulation.atol = self.atol
simulation.rtol = self.rtol
simulation.verbosity = self.verbosity
if hasattr(simulation, 'continuous_output'):
simulation.continuous_output = False # default 0, if one step approach should be used
elif hasattr(simulation, 'report_continuously'):
simulation.report_continuously = False # default 0, if one step approach should be used
simulation.inith = self.inith
# Calculate nOutputIntervals:
if gridWidth <> None:
nOutputIntervals = int((Tend - self.t0) / gridWidth)
else:
nOutputIntervals = nIntervals
# Check for feasible input parameters
if nOutputIntervals == 0:
print 'Error: gridWidth too high or nIntervals set to 0! Continue with nIntervals=1'
nOutputIntervals = 1
# Perform simulation
simulation.simulate(Tend, nOutputIntervals) # to get the values: t_new, y_new = simulation.simulate
def ode_sim(t_final):
y0 = get_initial() # initial conditions from Parameter.py
t0 = 0.0
param = new_param()
ecoli_ode = lambda t, x: rhs(t, x, param)
model = Explicit_Problem(ecoli_ode, y0, t0) # Create an Assimulo problem
model.name = 'E Coli ODE'
sim = CVode(model) # Create the solver CVode
sim.rtol = 1e-8
sim.atol = 1e-8
# pdb.set_trace()
t, y = sim.simulate(t_final) # Use the .simulate method to simulate and provide the final time
# Plot
met_labels = ["ACCOA", "ACEx", "ACO", "ACP", "ADP", "AKG", "AMP", "ASP", "ATP", "BPG", "CAMP", "CIT", "COA", "CYS",
"DAP", "E4P", "ei", "eiia", "eiiaP", "eiicb", "eiicbP", "eiP", "F6P", "FDP", "FUM", "G6P", "GAP",
"GL6P", "GLCx", "GLX", "HCO3", "hpr", "hprP", "icd", "icdP", "ICIT", "KDPG", "MAL", "MG", "MN", "NAD",
"NADH", "NADP", "NADPH", "OAA", "P", "PEP", "PGA2", "PGA3", "PGN", "PYR", "PYRx", "Q", "QH2", "R5P",
"RU5P", "S7P", "SUC", "SUCCOA", "SUCx", "tal", "talC3", "tkt", "tktC2", "X5P", "Px", "Pp", "GLCp",
"ACEp", "ACE", "Hc", "Hp", "FAD", "FADH2", "O2", "FEED"]
for i in y:
if i.any() < 0:
print i
plt.plot([t, t], [y[:, i] for i in [4, 9]], label=["ADP", "ATP"])
plt.title('Metabolite Concentrations Over Time')
plt.xlabel('Time')
plt.ylabel('Concentration')
plt.legend()
plt.savefig('concentration.png')
return model, sim
def test_elapsed_step_time(self):
rhs = lambda t, y: y
prob = Explicit_Problem(rhs, 0.0)
solv = Explicit_ODE(prob)
assert solv.get_elapsed_step_time() == -1.0
def run_example(with_plots=True):
#Defines the rhs
def f(t, y):
ydot = -y[0]
return N.array([ydot])
#Define an Assimulo problem
exp_mod = Explicit_Problem(f, 4.0)
exp_mod.name = 'Simple Explicit Example'
#Explicit Euler
exp_sim = ExplicitEuler(exp_mod) #Create a explicit Euler solver
exp_sim.options["continuous_output"] = True
#Simulate
t1, y1 = exp_sim.simulate(3) #Simulate 3 seconds
t2, y2 = exp_sim.simulate(5, 100) #Simulate 2 second more
#Basic test
nose.tools.assert_almost_equal(y2[-1], 0.02628193)
#Plot
if with_plots:
P.plot(t1, y1, color="b")
P.plot(t2, y2, color="b")
P.show()
def __init__(self,
rhs,
output_dt,
solver_dt,
y0,
args,
t0=0.,
console=False,
terminate=False,
terminate_depth=100.,
**kwargs):
self.terminate = terminate
super(CVODEIntegrator, self).__init__(rhs, output_dt, solver_dt, y0,
args, t0, console)
# Setup solver
if terminate:
self.prob = ExtendedProblem(self.rhs,
self.args,
terminate_depth,
y0=self.y0)
else:
self.prob = Explicit_Problem(self.rhs, self.y0)
self.sim = self._setup_sim(**kwargs)
self.kwargs = kwargs
def run_example(with_plots=True):
global exp_mod, exp_sim
#Define the rhs
def f(t, y):
ydot = -y[0]
return N.array([ydot])
#Define an Assimulo problem
exp_mod = Explicit_Problem(f, y0=4)
exp_mod.name = 'Simple CVode Example'
#Define an explicit solver
exp_sim = CVode(exp_mod) #Create a CVode solver
#Sets the parameters
exp_sim.iter = 'Newton' #Default 'FixedPoint'
exp_sim.discr = 'BDF' #Default 'Adams'
exp_sim.atol = [1e-4] #Default 1e-6
exp_sim.rtol = 1e-4 #Default 1e-6
#Simulate
t1, y1 = exp_sim.simulate(5, 100) #Simulate 5 seconds
t2, y2 = exp_sim.simulate(7) #Simulate 2 seconds more
#Basic test
nose.tools.assert_almost_equal(y2[-1], 0.00347746, 5)
def simulate_ode(fun, y_initial, tf, opts):
"function to run CVode solver on given problem"
# get options
ode_opts, ode_system_options = opts
# iter, discretization_method, atol, rtol, time_points = ode_opts
iter = ode_opts["iter"]
discretization_method = ode_opts["discr"]
atol = ode_opts["atol"]
rtol = ode_opts["rtol"]
time_points = ode_opts["time_points"]
try:
display_progress = ode_opts["display_progress"]
except KeyError:
display_progress = True
try:
verbosity = ode_opts["verbosity"]
except KeyError:
verbosity = 10
# define explicit assimulo problem
prob = Explicit_Problem(lambda t, x: fun(t, x, ode_system_options),
y0=y_initial)
# create solver instance
solver = CVode(prob)
# set solver options
solver.iter, solver.discr, solver.atol, solver.rtol, solver.display_progress, solver.verbosity = \
iter, discretization_method, atol, rtol, display_progress, verbosity
# simulate system
time_course, y_result = solver.simulate(tf, time_points)
return time_course, y_result, prob, solver
def test_usejac_csc_matrix(self):
"""
This tests the functionality of the property usejac.
"""
f = lambda t, x: N.array([x[1], -9.82]) #Defines the rhs
jac = lambda t, x: sp.csc_matrix(N.array([[0., 1.], [0., 0.]])
) #Defines the jacobian
exp_mod = Explicit_Problem(f, [1.0, 0.0])
exp_mod.jac = jac
exp_sim = CVode(exp_mod)
exp_sim.discr = 'BDF'
exp_sim.iter = 'Newton'
exp_sim.simulate(5., 100)
assert exp_sim.statistics["nfcnjacs"] == 0
nose.tools.assert_almost_equal(exp_sim.y_sol[-1][0], -121.75000143, 4)
exp_sim.reset()
exp_sim.usejac = False
exp_sim.simulate(5., 100)
nose.tools.assert_almost_equal(exp_sim.y_sol[-1][0], -121.75000143, 4)
assert exp_sim.statistics["nfcnjacs"] > 0
def test_completed_step(self):
"""
This tests the functionality of the method completed_step.
"""
global nsteps
nsteps = 0
f = lambda t, x: x**0.25
def completed_step(solver):
global nsteps
nsteps += 1
mod = Explicit_Problem(f, 1.0)
mod.step_events = completed_step
sim = CVode(mod)
sim.simulate(2., 100)
assert len(sim.t_sol) == 101
assert nsteps == sim.statistics["nsteps"]
sim = CVode(mod)
nsteps = 0
sim.simulate(2.)
assert len(sim.t_sol) == sim.statistics["nsteps"] + 1
assert nsteps == sim.statistics["nsteps"]
def run_example(with_plots=True):
r"""
Example for the use of the implicit Euler method to solve
Van der Pol's equation
.. math::
\dot y_1 &= y_2 \\
\dot y_2 &= \mu ((1.-y_1^2) y_2-y_1)
with :math:`\mu= 10^6`.
on return:
- :dfn:`exp_mod` problem instance
- :dfn:`exp_sim` solver instance
"""
#Define the rhs
def f(t, y):
eps = 1.e-6
my = 1. / eps
yd_0 = y[1]
yd_1 = my * ((1. - y[0]**2) * y[1] - y[0])
return N.array([yd_0, yd_1])
y0 = [2.0, -0.6] #Initial conditions
#Define an Assimulo problem
exp_mod = Explicit_Problem(f, y0)
exp_mod.name = 'Van der Pol (explicit)'
#Define an explicit solver
exp_sim = Radau5ODE(exp_mod) #Create a Radau5 solver
#Sets the parameters
exp_sim.atol = 1e-4 #Default 1e-6
exp_sim.rtol = 1e-4 #Default 1e-6
exp_sim.inith = 1.e-4 #Initial step-size
#Simulate
t, y = exp_sim.simulate(2.) #Simulate 2 seconds
#Plot
if with_plots:
import pylab as P
P.plot(t, y[:, 0]) #, marker='o')
P.xlabel('Time')
P.ylabel('State')
P.title(exp_mod.name)
P.show()
#Basic test
x1 = y[:, 0]
assert N.abs(x1[-1] - 1.706168035) < 1e-3 #For test purpose
return exp_mod, exp_sim
def test_time_event(self):
f = lambda t, y: [1.0]
global tnext
global nevent
tnext = 0.0
nevent = 0
def time_events(t, y, sw):
global tnext, nevent
events = [1.0, 2.0, 2.5, 3.0]
for ev in events:
if t < ev:
tnext = ev
break
else:
tnext = None
nevent += 1
return tnext
def handle_event(solver, event_info):
solver.y += 1.0
global tnext
nose.tools.assert_almost_equal(solver.t, tnext)
assert event_info[0] == []
assert event_info[1] == True
exp_mod = Explicit_Problem(f, 0.0)
exp_mod.time_events = time_events
exp_mod.handle_event = handle_event
#CVode
exp_sim = CVode(exp_mod)
exp_sim(5., 100)
assert nevent == 5
def run_example(with_plots=True):
r"""
Example for the use of LSODAR method to solve
Van der Pol's equation
.. math::
\dot y_1 &= y_2 \\
\dot y_2 &= \mu ((1.-y_1^2) y_2-y_1)
with :math:`\mu=\frac{1}{5} 10^3`.
on return:
- :dfn:`exp_mod` problem instance
- :dfn:`exp_sim` solver instance
"""
#Define the rhs
def f(t, y):
eps = 1.e-6
my = 1. / eps
yd_0 = y[1]
yd_1 = my * ((1. - y[0]**2) * y[1] - y[0])
return N.array([yd_0, yd_1])
y0 = [2.0, -0.6] #Initial conditions
#Define an Assimulo problem
exp_mod = Explicit_Problem(f, y0, name="LSODAR: Van der Pol's equation")
#Define an explicit solver
exp_sim = LSODAR(exp_mod) #Create a Radau5 solver
#Sets the parameters
exp_sim.atol = 1e-4 #Default 1e-6
exp_sim.rtol = 1e-4 #Default 1e-6
#Simulate
t, y = exp_sim.simulate(2.) #Simulate 2 seconds
#Plot
if with_plots:
P.plot(t, y[:, 0], marker='o')
P.title(exp_mod.name)
P.ylabel("State: $y_1$")
P.xlabel("Time")
P.show()
#Basic test
x1 = y[:, 0]
assert N.abs(x1[-1] - 1.706168035) < 1e-3 #For test purpose
return exp_mod, exp_sim
def setUp(self):
"""
This function sets up the test case.
"""
f = lambda t, y: N.array(y)
y0 = [1.0]
self.problem = Explicit_Problem(f, y0)
self.simulator = CVode(self.problem)
def setUp(self):
"""
This function sets up the test case.
"""
f = lambda t, y: 1.0
y0 = 1
self.problem = Explicit_Problem(f, y0)
self.simulator = Dopri5(self.problem)
def test_backward_integration(self):
def f(t, y):
x, v = y
return [x, -x - 0.1 * v]
mod = Explicit_Problem(f, y0=[1, 0], t0=10)
sim = CVode(mod)
sim.backward = True
t, y = sim.simulate(0, ncp_list=np.arange(1, 10))
assert np.all(t == np.arange(0, 11)[::-1])
mod = Explicit_Problem(f, y0=[1, 0], t0=10)
sim = CVode(mod)
sim.backward = True
t, y = sim.simulate(0, ncp_list=np.arange(1, 10)[::-1])
assert np.all(t == np.arange(0, 11)[::-1])
def test_ncp_list(self):
f = lambda t,y:N.array(-y)
y0 = [4.0]
prob = Explicit_Problem(f,y0)
sim = CVode(prob)
t, y = sim.simulate(7, ncp_list=N.arange(0, 7, 0.1)) #Simulate 5 seconds
nose.tools.assert_almost_equal(float(y[-1]), 0.00364832, 4)
def _assimulo_problem(self):
rhs = self._problem.right_hand_side_as_function
parameters = self._parameters
initial_conditions = self._initial_conditions
initial_timepoint = self._starting_time
model = Explicit_Problem(lambda t, x: rhs(x, parameters),
initial_conditions, initial_timepoint)
return model
def test_time_limit(self):
f = lambda t, y: -y
exp_mod = Explicit_Problem(f, 1.0)
exp_sim = CVode(exp_mod)
exp_sim.maxh = 1e-8
exp_sim.time_limit = 1 #One second
exp_sim.report_continuously = True
nose.tools.assert_raises(TimeLimitExceeded, exp_sim.simulate, 1)
def setUp(self):
"""
This sets up the test case.
"""
f = lambda t,y:[1.0,2.0]
#Define an Assimulo problem
y0 = [2.0,-0.6] #Initial conditions
exp_mod = Explicit_Problem(f,y0)
self.sim = Radau5ODE(exp_mod)
def test_exception(self):
"""
This tests that exceptions are no caught when evaluating the RHS in ExpEuler.
"""
def f(t, y):
raise NotImplementedError
prob = Explicit_Problem(f, 0.0)
sim = ExplicitEuler(prob)
nose.tools.assert_raises(NotImplementedError, sim.simulate, 1.0)
def setUp(self):
#Define the rhs
def f(t, y):
eps = 1.e-6
my = 1. / eps
yd_0 = y[1]
yd_1 = my * ((1. - y[0]**2) * y[1] - y[0])
return N.array([yd_0, yd_1])
#Define the jacobian
def jac(t, y):
eps = 1.e-6
my = 1. / eps
j = N.array(
[[0.0, 1.0],
[my * ((-2.0 * y[0]) * y[1] - 1.0), my * (1.0 - y[0]**2)]])
return j
def jac_sparse(t, y):
eps = 1.e-6
my = 1. / eps
J = N.zeros([2, 2])
J[0, 0] = 0.
J[0, 1] = 1.
J[1, 0] = my * (-2. * y[0] * y[1] - 1.)
J[1, 1] = my * (1. - y[0]**2)
return sp.csc_matrix(J)
y0 = [2.0, -0.6] #Initial conditions
#Define an Assimulo problem
exp_mod = Explicit_Problem(f, y0, name='Van der Pol (explicit)')
exp_mod_sp = Explicit_Problem(f, y0, name='Van der Pol (explicit)')
exp_mod.jac = jac
exp_mod_sp.jac = jac_sparse
self.mod = exp_mod
self.mod_sp = exp_mod_sp
def test_spgmr(self):
f = lambda t, y: N.array([y[1], -9.82])
fsw = lambda t, y, sw: N.array([y[1], -9.82])
fp = lambda t, y, p: N.array([y[1], -9.82])
fswp = lambda t, y, sw, p: N.array([y[1], -9.82])
jacv = lambda t, y, fy, v: N.dot(N.array([[0, 1.], [0, 0]]), v)
jacvsw = lambda t, y, fy, v, sw: N.dot(N.array([[0, 1.], [0, 0]]), v)
jacvp = lambda t, y, fy, v, p: N.dot(N.array([[0, 1.], [0, 0]]), v)
jacvswp = lambda t, y, fy, v, sw, p: N.dot(N.array([[0, 1.], [0, 0]]),
v)
y0 = [1.0, 0.0] #Initial conditions
def run_sim(exp_mod):
exp_sim = CVode(exp_mod) #Create a CVode solver
exp_sim.linear_solver = 'SPGMR' #Change linear solver
#Simulate
t, y = exp_sim.simulate(
5, 1000) #Simulate 5 seconds with 1000 communication points
#Basic tests
nose.tools.assert_almost_equal(y[-1][0], -121.75000000, 4)
nose.tools.assert_almost_equal(y[-1][1], -49.100000000)
exp_mod = Explicit_Problem(f, y0)
exp_mod.jacv = jacv #Sets the jacobian
run_sim(exp_mod)
#Need someway of suppressing error messages from deep down in the Cython wrapper
#See http://stackoverflow.com/questions/1218933/can-i-redirect-the-stdout-in-python-into-some-sort-of-string-buffer
try:
from cStringIO import StringIO
except ImportError:
from io import StringIO
import sys
stderr = sys.stderr
sys.stderr = StringIO()
exp_mod = Explicit_Problem(f, y0)
exp_mod.jacv = jacvsw #Sets the jacobian
nose.tools.assert_raises(CVodeError, run_sim, exp_mod)
exp_mod = Explicit_Problem(fswp, y0, sw0=[True], p0=1.0)
exp_mod.jacv = jacvsw #Sets the jacobian
nose.tools.assert_raises(CVodeError, run_sim, exp_mod)
#Restore standard error
sys.stderr = stderr
exp_mod = Explicit_Problem(fp, y0, p0=1.0)
exp_mod.jacv = jacvp #Sets the jacobian
run_sim(exp_mod)
exp_mod = Explicit_Problem(fsw, y0, sw0=[True])
exp_mod.jacv = jacvsw #Sets the jacobian
run_sim(exp_mod)
exp_mod = Explicit_Problem(fswp, y0, sw0=[True], p0=1.0)
exp_mod.jacv = jacvswp #Sets the jacobian
run_sim(exp_mod)
def simulate(self, Tend, nIntervals, gridWidth):
problem = Explicit_Problem(self.rhs, self.y0)
problem.name = 'CVode'
# solver.rhs = self.right_hand_side
problem.handle_result = self.handle_result
problem.state_events = self.state_events
problem.handle_event = self.handle_event
problem.time_events = self.time_events
problem.finalize = self.finalize
simulation = CVode(problem)
# Change multistep method: 'adams' or 'VDF'
if self.discr == 'Adams':
simulation.discr = 'Adams'
simulation.maxord = 12
else:
simulation.discr = 'BDF'
simulation.maxord = 5
# Change iteration algorithm: functional(FixedPoint) or newton
if self.iter == 'FixedPoint':
simulation.iter = 'FixedPoint'
else:
simulation.iter = 'Newton'
# Sets additional parameters
simulation.atol = self.atol
simulation.rtol = self.rtol
simulation.verbosity = self.verbosity
if hasattr(simulation, 'continuous_output'):
simulation.continuous_output = False # default 0, if one step approach should be used
elif hasattr(simulation, 'report_continuously'):
simulation.report_continuously = False # default 0, if one step approach should be used
# '''Initialize problem '''
# self.t_cur = self.t0
# self.y_cur = self.y0
# Calculate nOutputIntervals:
if gridWidth <> None:
nOutputIntervals = int((Tend - self.t0) / gridWidth)
else:
nOutputIntervals = nIntervals
# Check for feasible input parameters
if nOutputIntervals == 0:
print 'Error: gridWidth too high or nIntervals set to 0! Continue with nIntervals=1'
nOutputIntervals = 1
# Perform simulation
simulation.simulate(
Tend, nOutputIntervals
) # to get the values: t_new, y_new = simulation.simulate
def _assimulo_problem(self):
rhs = self._problem.right_hand_side_as_function
parameters = self._parameters
initial_conditions = self._initial_conditions
initial_timepoint = self._starting_time
# Solvers with sensitivity support should be able to accept parameters
# into rhs function directly
model = Explicit_Problem(lambda t, x, p: rhs(x, p), initial_conditions,
initial_timepoint)
model.p0 = np.array(parameters)
return model
def test_stiff_problem(self):
f = lambda t, y: -15.0 * y
y0 = 1.0
problem = Explicit_Problem(f, y0)
simulator = ImplicitEuler(problem)
t, y = simulator.simulate(1)
y_correct = lambda t: N.exp(-15 * t)
abs_err = N.abs(y[:, 0] - y_correct(N.array(t)))
assert N.max(abs_err) < 0.1
def simulate_prob(t_start, t_stop, x0, p, ncp, with_plots=False):
"""Simulates the problem using Assimulo.
Args:
t_start (double): Simulation start time.
t_stop (double): Simulation stop time.
x0 (list): Initial value.
p (list): Problem specific parameters.
ncp (int): Number of communication points.
with_plots (bool): Plots the solution.
Returns:
tuple: (t,y). Time vector and solution at each time.
"""
# Assimulo
# Define the right-hand side
def f(t, y):
xd_1 = p[0] * y[0]
xd_2 = p[1] * (y[1] - y[0]**2)
return np.array([xd_1, xd_2])
# Define an Assimulo problem
exp_mod = Explicit_Problem(f, y0=x0, name='Planar ODE')
# Define an explicit solver
exp_sim = CVode(exp_mod)
# Sets the solver parameters
exp_sim.atol = 1e-12
exp_sim.rtol = 1e-11
# Simulate
t, y = exp_sim.simulate(tfinal=t_stop, ncp=ncp)
# Plot
if with_plots:
x1 = y[:, 0]
x2 = y[:, 1]
plt.figure()
plt.title('Planar ODE')
plt.plot(t, x1, 'b')
plt.plot(t, x2, 'k')
plt.legend(['x1', 'x2'])
plt.xlim(t_start, t_stop)
plt.xlabel('Time (s)')
plt.ylabel('x')
plt.grid(True)
return t, y.T
def run_example(with_plots=True):
"""
The same as example :doc:`EXAMPLE_cvode_basic` but now integrated backwards in time.
on return:
- :dfn:`exp_mod` problem instance
- :dfn:`exp_sim` solver instance
"""
#Define the rhs
def f(t, y):
ydot = -y[0]
return N.array([ydot])
#Define an Assimulo problem
exp_mod = Explicit_Problem(
f,
t0=5,
y0=0.02695,
name=r'CVode Test Example (reverse time): $\dot y = - y$ ')
#Define an explicit solver
exp_sim = CVode(exp_mod) #Create a CVode solver
#Sets the parameters
exp_sim.iter = 'Newton' #Default 'FixedPoint'
exp_sim.discr = 'BDF' #Default 'Adams'
exp_sim.atol = [1e-8] #Default 1e-6
exp_sim.rtol = 1e-8 #Default 1e-6
exp_sim.backward = True
#Simulate
t, y = exp_sim.simulate(0) #Simulate 5 seconds (t0=5 -> tf=0)
#print 'y(5) = {}, y(0) ={}'.format(y[0][0],y[-1][0])
#Basic test
nose.tools.assert_almost_equal(float(y[-1]), 4.00000000, 3)
#Plot
if with_plots:
P.plot(t, y, color="b")
P.title(exp_mod.name)
P.ylabel('y')
P.xlabel('Time')
P.show()
return exp_mod, exp_sim
def run_example(with_plots=True):
r"""
Demonstration of the use of CVode by solving the
linear test equation :math:`\dot y = - y`
on return:
- :dfn:`exp_mod` problem instance
- :dfn:`exp_sim` solver instance
"""
#Define the rhs
def f(t, y):
ydot = -y[0]
return N.array([ydot])
#Define an Assimulo problem
exp_mod = Explicit_Problem(f,
y0=4,
name=r'CVode Test Example: $\dot y = - y$')
#Define an explicit solver
exp_sim = CVode(exp_mod) #Create a CVode solver
#Sets the parameters
exp_sim.iter = 'Newton' #Default 'FixedPoint'
exp_sim.discr = 'BDF' #Default 'Adams'
exp_sim.atol = [1e-4] #Default 1e-6
exp_sim.rtol = 1e-4 #Default 1e-6
#Simulate
t1, y1 = exp_sim.simulate(5, 100) #Simulate 5 seconds
t2, y2 = exp_sim.simulate(7) #Simulate 2 seconds more
#Plot
if with_plots:
import pylab as P
P.plot(t1, y1, color="b")
P.plot(t2, y2, color="r")
P.title(exp_mod.name)
P.ylabel('y')
P.xlabel('Time')
P.show()
#Basic test
nose.tools.assert_almost_equal(float(y2[-1]), 0.00347746, 5)
nose.tools.assert_almost_equal(exp_sim.get_last_step(), 0.0222169642893, 3)
return exp_mod, exp_sim
