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):
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 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 run_example(with_plots=True):
"""
This is the same example from the Sundials package (cvsRoberts_FSA_dns.c)
This simple example problem for CVode, due to Robertson,
is from chemical kinetics, and consists of the following three
equations::
dy1/dt = -p1*y1 + p2*y2*y3
dy2/dt = p1*y1 - p2*y2*y3 - p3*y2**2
dy3/dt = p3*(y2)^2
"""
def f(t, y, p):
yd_0 = -p[0]*y[0]+p[1]*y[1]*y[2]
yd_1 = p[0]*y[0]-p[1]*y[1]*y[2]-p[2]*y[1]**2
yd_2 = p[2]*y[1]**2
return N.array([yd_0,yd_1,yd_2])
#The initial conditions
y0 = [1.0,0.0,0.0] #Initial conditions for y
#Create an Assimulo explicit problem
exp_mod = Explicit_Problem(f,y0)
#Sets the options to the problem
exp_mod.p0 = [0.040, 1.0e4, 3.0e7] #Initial conditions for parameters
exp_mod.pbar = [0.040, 1.0e4, 3.0e7]
#Create an Assimulo explicit solver (CVode)
exp_sim = CVode(exp_mod)
#Sets the paramters
exp_sim.iter = 'Newton'
exp_sim.discr = 'BDF'
exp_sim.rtol = 1.e-4
exp_sim.atol = N.array([1.0e-8, 1.0e-14, 1.0e-6])
exp_sim.sensmethod = 'SIMULTANEOUS' #Defines the sensitvity method used
exp_sim.suppress_sens = False #Dont suppress the sensitivity variables in the error test.
exp_sim.continuous_output = True
#Simulate
t, y = exp_sim.simulate(4,400) #Simulate 4 seconds with 400 communication points
#Basic test
nose.tools.assert_almost_equal(y[-1][0], 9.05518032e-01, 4)
nose.tools.assert_almost_equal(y[-1][1], 2.24046805e-05, 4)
nose.tools.assert_almost_equal(y[-1][2], 9.44595637e-02, 4)
nose.tools.assert_almost_equal(exp_sim.p_sol[0][-1][0], -1.8761, 2) #Values taken from the example in Sundials
nose.tools.assert_almost_equal(exp_sim.p_sol[1][-1][0], 2.9614e-06, 8)
nose.tools.assert_almost_equal(exp_sim.p_sol[2][-1][0], -4.9334e-10, 12)
#Plot
if with_plots:
P.plot(t, y)
P.show()
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_handle_result(self):
"""
This function tests the handle result.
"""
f = lambda t,x: x**0.25
def handle_result(solver,t,y):
assert solver.t == t
prob = Explicit_Problem(f, [1.0])
prob.handle_result = handle_result
sim = CVode(prob)
sim.continuous_output = True
sim.simulate(10.)
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 run_example(with_plots=True):
#Defines the rhs
def f(t,y):
yd_0 = y[1]
yd_1 = -9.82
return N.array([yd_0,yd_1])
#Defines the jacobian*vector product
def jacv(t,y,fy,v):
j = N.array([[0,1.],[0,0]])
return N.dot(j,v)
y0 = [1.0,0.0] #Initial conditions
#Defines an Assimulo explicit problem
exp_mod = Explicit_Problem(f,y0)
exp_mod.jacv = jacv #Sets the jacobian
exp_mod.name = 'Example using the Jacobian Vector product'
exp_sim = CVode(exp_mod) #Create a CVode solver
#Set the parameters
exp_sim.iter = 'Newton' #Default 'FixedPoint'
exp_sim.discr = 'BDF' #Default 'Adams'
exp_sim.atol = 1e-5 #Default 1e-6
exp_sim.rtol = 1e-5 #Default 1e-6
exp_sim.linear_solver = 'SPGMR' #Change linear solver
#exp_sim.options["usejac"] = False
#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)
#Plot
if with_plots:
P.plot(t,y)
P.show()
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)
self.simulator.verbosity = 0
def run_example(with_plots=True):
global t,y
#Defines the rhs
def f(t,y):
yd_0 = y[1]
yd_1 = -9.82
#print y, yd_0, yd_1
return N.array([yd_0,yd_1])
#Defines the jacobian
def jac(t,y):
j = N.array([[0,1.],[0,0]])
return j
#Defines an Assimulo explicit problem
y0 = [1.0,0.0] #Initial conditions
exp_mod = Explicit_Problem(f,y0)
exp_mod.jac = jac #Sets the jacobian
exp_mod.name = 'Example using Jacobian'
exp_sim = CVode(exp_mod) #Create a CVode solver
#Set the parameters
exp_sim.iter = 'Newton' #Default 'FixedPoint'
exp_sim.discr = 'BDF' #Default 'Adams'
exp_sim.atol = 1e-5 #Default 1e-6
exp_sim.rtol = 1e-5 #Default 1e-6
#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)
#Plot
if with_plots:
P.plot(t,y,linestyle="dashed",marker="o") #Plot the solution
P.show()
def test_switches(self):
"""
This tests that the switches are actually turned when override.
"""
f = lambda t,x,sw: N.array([1.0])
state_events = lambda t,x,sw: N.array([x[0]-1.])
def handle_event(solver, event_info):
solver.sw = [False] #Override the switches to point to another instance
mod = Explicit_Problem(f,[0.0])
mod.sw0 = [True]
mod.state_events = state_events
mod.handle_event = handle_event
sim = CVode(mod)
assert sim.sw[0] == True
sim.simulate(3)
assert sim.sw[0] == False
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 run_example(with_plots=True):
global t, y
#Defines the rhs
def f(t, y):
yd_0 = y[1]
yd_1 = -9.82
#print y, yd_0, yd_1
return N.array([yd_0, yd_1])
#Defines the jacobian
def jac(t, y):
j = N.array([[0, 1.], [0, 0]])
return j
#Defines an Assimulo explicit problem
y0 = [1.0, 0.0] #Initial conditions
exp_mod = Explicit_Problem(f, y0)
exp_mod.jac = jac #Sets the jacobian
exp_mod.name = 'Example using Jacobian'
exp_sim = CVode(exp_mod) #Create a CVode solver
#Set the parameters
exp_sim.iter = 'Newton' #Default 'FixedPoint'
exp_sim.discr = 'BDF' #Default 'Adams'
exp_sim.atol = 1e-5 #Default 1e-6
exp_sim.rtol = 1e-5 #Default 1e-6
#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)
#Plot
if with_plots:
P.plot(t, y, linestyle="dashed", marker="o") #Plot the solution
P.show()
def test_switches(self):
"""
This tests that the switches are actually turned when override.
"""
f = lambda t,x,sw: N.array([1.0])
state_events = lambda t,x,sw: N.array([x[0]-1.])
def handle_event(solver, event_info):
solver.sw = [False] #Override the switches to point to another instance
mod = Explicit_Problem(f,[0.0])
mod.sw0 = [True]
mod.state_events = state_events
mod.handle_event = handle_event
sim = Radau5ODE(mod)
assert sim.sw[0] == True
sim.simulate(3)
assert sim.sw[0] == False
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 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
#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.jac = jac
self.mod = exp_mod
#Define an explicit solver
self.sim = _Radau5ODE(exp_mod) #Create a Radau5 solve
self.sim_t0 = _Radau5ODE(exp_mod_t0)
#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 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
#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.jac = jac
self.mod = exp_mod
#Define an explicit solver
self.sim = Radau5ODE(exp_mod) #Create a Radau5 solve
self.sim_t0 = Radau5ODE(exp_mod_t0)
#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 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_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 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):
"""
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 = LSODAR(exp_mod) #Create a LSODAR solve
self.sim_sp = LSODAR(exp_mod_sp)
#Sets the parameters
self.sim.atol = 1e-6 #Default 1e-6
self.sim.rtol = 1e-6 #Default 1e-6
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 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):
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
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 test_change_norm(self):
assert self.simulator.options["norm"] == "WRMS"
self.simulator.norm = 'WRMS'
assert self.simulator.norm == 'WRMS'
self.simulator.norm = 'EUCLIDEAN'
assert self.simulator.options["norm"] == "EUCLIDEAN"
assert self.simulator.norm == 'EUCLIDEAN'
f = lambda t, y: N.array([1.0])
y0 = 4.0 #Initial conditions
exp_mod = Explicit_Problem(f, y0)
exp_sim = CVode(exp_mod) #Create a CVode solver
exp_sim.norm = "WRMS"
exp_sim.simulate(1)
exp_mod = Explicit_Problem(f, y0)
exp_sim = CVode(exp_mod) #Create a CVode solver
exp_sim.norm = "EUCLIDEAN"
exp_sim.simulate(1)
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 = ImplicitEuler(exp_mod)
exp_sim.simulate(5., 100)
assert exp_sim.statistics["nfcnjacs"] == 0
nose.tools.assert_almost_equal(exp_sim.y_sol[-1][0], -121.995500, 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.995500, 4)
assert exp_sim.statistics["nfcnjacs"] > 0
def test_re_init(self):
rhs = lambda t, y: y
prob = Explicit_Problem(rhs, 0.0)
solv = Explicit_ODE(prob)
assert solv.t == 0.0
assert solv.y[0] == 0.0
solv.re_init(1.0, 2.0)
assert solv.t == 1.0
assert solv.y[0] == 2.0
def run_example():
def rhs(t,y):
A =N.array([[0,1],[-2,-1]])
yd=N.dot(A,y)
return yd
y0=N.array([1.0,1.0])
t0=0.0
model = Explicit_Problem(rhs,y0,t0) #Create an Assimulo problem
model.name = 'Linear Test ODE'
sim = CVode(model) #Create the solver CVode
tfinal = 10.0 #Specify the final time
t,y = sim.simulate(tfinal) #Use the .simulate method to simulate and provide the final time
#Plot
P.plot(t,y)
P.show()
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'
exp_sim = RungeKutta4(exp_mod) #Create a RungeKutta4 solver
#Simulate
t, y = exp_sim.simulate(5, 100) #Simulate 5 seconds
#Basic test
nose.tools.assert_almost_equal(y[-1],0.02695179)
#Plot
if with_plots:
P.plot(t,y)
P.show()
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'
exp_sim = RungeKutta4(exp_mod) #Create a RungeKutta4 solver
#Simulate
t, y = exp_sim.simulate(5, 100) #Simulate 5 seconds
#Basic test
nose.tools.assert_almost_equal(y[-1], 0.02695179)
#Plot
if with_plots:
P.plot(t, y)
P.show()
def test_simulate_explicit(self):
"""
Test a simulation of an explicit problem using IDA.
"""
f = lambda t, y: N.array(-y)
y0 = [1.0]
problem = Explicit_Problem(f, y0)
simulator = IDA(problem)
assert simulator.yd0[0] == -simulator.y0[0]
t, y = simulator.simulate(1.0)
nose.tools.assert_almost_equal(float(y[-1]), float(N.exp(-1.0)), 4)
def test_usejac(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: 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["nfevalsLS"] == 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["nfevalsLS"] > 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 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 test_interpolate(self):
"""
This tests the functionality of the method interpolate.
"""
f = lambda t, x: N.array(x**0.25)
prob = Explicit_Problem(f, [1.0])
sim = CVode(prob)
sim.simulate(10., 100)
y100 = sim.y_sol
t100 = sim.t_sol
sim.reset()
sim.simulate(10.)
nose.tools.assert_almost_equal(y100[-2], sim.interpolate(9.9, 0), 5)
def run_example(with_plots=True):
#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:
P.plot(t,y[:,0], marker='o')
P.show()
#Basic test
x1 = y[:,0]
assert N.abs(x1[-1]-1.706168035) < 1e-3 #For test purpose
def test_usejac(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: 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["nfevalsLS"] == 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["nfevalsLS"] > 0
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 test_change_discr(self):
"""
This tests that the change from Functional to Newton works
"""
f = lambda t, y: N.array([1.0])
y0 = 4.0 #Initial conditions
exp_mod = Explicit_Problem(f, y0)
exp_sim = CVode(exp_mod) #Create a CVode solver
exp_sim.iter = "FixedPoint"
exp_sim.simulate(1)
assert exp_sim.statistics["njevals"] == 0
exp_sim.iter = "Newton"
exp_sim.simulate(2)
assert exp_sim.statistics["njevals"] > 0
def doSimulate():
theta0 = 1.0 # radianer, startvinkel från lodrätt
tfinal = 3
title = 'k = {0}, stretch = {1}, {2}'.format(k, stretch, solver)
r0 = 1.0 + stretch
x0 = r0 * np.sin(theta0)
y0 = -r0 * np.cos(theta0)
t0 = 0.0
y_init = np.array([x0, y0, 0, 0])
ElasticSpring = Explicit_Problem(rhs, y_init, t0)
if solver.lower() == "cvode":
sim = CVode(ElasticSpring)
elif solver.lower() == "bdf_2":
sim = BDF_2(ElasticSpring)
elif solver.lower() == "ee":
sim = EE(ElasticSpring)
else:
sim == None
raise ValueError('Expected "CVode", "EE" or "BDF_2"')
sim.report_continuously = False
npoints = 100 * tfinal
#t,y = sim.simulate(tfinal,npoints)
try:
#for i in [1]:
t, y = sim.simulate(tfinal)
xpos, ypos = y[:, 0], y[:, 1]
#plt.plot(t,y[:,0:2])
plt.plot(xpos, ypos)
plt.plot(xpos[0], ypos[0], 'or')
plt.xlabel('y_1')
plt.ylabel('y_2')
plt.title(title)
plt.axis('equal')
plt.show()
except Explicit_ODE_Exception as e:
print(e.message)
print("for the case {0}.".format(title))
def run_example(with_plots=True):
r"""
Demonstration of the use of the use of the explicit euler method by solving the
linear test equation :math:`\dot y = - y`
on return:
- :dfn:`exp_mod` problem instance
- :dfn:`exp_sim` solver instance
"""
#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,
name='ExplicitEuler Example: $\dot y = - y$')
#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
#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.02628193)
return exp_mod, exp_sim
def run_example(with_plots=True):
r"""
Demonstration of the use of the use of Runge-Kutta 34 by solving the
linear test equation :math:`\dot y = - y`
on return:
- :dfn:`exp_mod` problem instance
- :dfn:`exp_sim` solver instance
"""
#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, name='RK34 Example: $\dot y = - y$')
exp_sim = RungeKutta34(exp_mod) #Create a RungeKutta34 solver
exp_sim.inith = 0.1 #Sets the initial step, default = 0.01
#Simulate
t, y = exp_sim.simulate(5) #Simulate 5 seconds
#Basic test
nose.tools.assert_almost_equal(float(y[-1]), 0.02695199, 5)
#Plot
if with_plots:
import pylab as P
P.plot(t, y)
P.title(exp_mod.name)
P.ylabel('y')
P.xlabel('Time')
P.show()
return exp_mod, exp_sim
def test_pbar(self):
"""
Tests the property of pbar.
"""
f = lambda t, y, p: N.array([0.0] * len(y))
y0 = [1.0] * 2
p0 = [1000.0, -100.0]
exp_mod = Explicit_Problem(f, y0, p0=p0)
exp_sim = CVode(exp_mod)
nose.tools.assert_almost_equal(exp_sim.pbar[0], 1000.00000, 4)
nose.tools.assert_almost_equal(exp_sim.pbar[1], 100.000000, 4)
f = lambda t, y, yd, p: N.array([0.0] * len(y))
yd0 = [0.0] * 2
imp_mod = Implicit_Problem(f, y0, yd0, p0=p0)
imp_sim = IDA(imp_mod)
nose.tools.assert_almost_equal(imp_sim.pbar[0], 1000.00000, 4)
nose.tools.assert_almost_equal(imp_sim.pbar[1], 100.000000, 4)
def create_model():
def pendulum(t, X, sw):
"""
The ODE to be simulated. The parameter sw should be fixed during
the simulation and only be changed during the event handling.
"""
X = X.copy()
X[0] = X[1]
X[1] = -1 + 0.04 * (X[1]**2) * np.sin(X[1])
X[2] = 1
return X
def state_events(t, X, sw):
"""
This is our function that keep track of our events, when the sign
of any of the events has changed, we have an event.
"""
return [X[0] - np.sin(X[2])]
def handle_event(solver, event_info):
"""
Event handling. This functions is called when Assimulo finds an event as
specified by the event functions.
"""
state_info = event_info[0] #We are only interested in state events info
if state_info[0] != 0: #Check if the first event function have been triggered
if solver.sw[0]: #If the switch is True the pendulum bounces
X = solver.y
if X[1] - np.cos(X[2]) < 0:
X[1] = -0.9*X[1] + 1.9*np.cos(X[2])
#solver.sw[0] = not solver.sw[0] #Change event function
#Initial values
y0 = [0, 0, 0] #Initial states
t0 = 0.0 #Initial time
switches0 = [True] #Initial switches
#Create an Assimulo Problem
mod = Explicit_Problem(pendulum, y0, t0, sw0=switches0)
mod.state_events = state_events #Sets the state events to the problem
mod.handle_event = handle_event #Sets the event handling to the problem
mod.name = 'Bouncing Ball on Sonusoidal Platform' #Sets the name of the problem
#Create an Assimulo solver (CVode)
sim = CVode(mod)
#sim = LSODAR(mod)
#sim.options['verbosity'] = 20 #LOUD
sim.options['verbosity'] = 40 #WHISPER
#sim.options['minh'] = 1e-4
#sim.options['rtol'] = 1e-3
#Specifies options
sim.discr = 'Adams' #Sets the discretization method
sim.iter = 'FixedPoint' #Sets the iteration method
sim.rtol = 1.e-8 #Sets the relative tolerance
sim.atol = 1.e-6 #Sets the absolute tolerance
return sim
def create_model():
def pendulum(t, X, sw):
"""
The ODE to be simulated. The parameter sw should be fixed during
the simulation and only be changed during the event handling.
"""
g = 1
Y = X.copy()
Y[0] = X[2] #x_dot
Y[1] = X[3] #y_dot
Y[2] = 0 #vx_dot
Y[3] = -g #vy_dot
return Y
def state_events(t, X, sw):
"""
This is our function that keep track of our events, when the sign
of any of the events has changed, we have an event.
"""
return [X[1]] # y == 0
def handle_event(solver, event_info):
"""
Event handling. This functions is called when Assimulo finds an event as
specified by the event functions.
"""
state_info = event_info[0] #We are only interested in state events info
if state_info[0] != 0: #Check if the first event function have been triggered
if solver.sw[0]:
X = solver.y
if X[3] < 0: # if the ball is falling (vy < 0)
# bounce!
X[1] = 1e-5
X[3] = -0.75*X[3]
#solver.sw[0] = not solver.sw[0] #Change event function
#Initial values
y0 = [0., 0., 0., 0.] #Initial states
t0 = 0.0 #Initial time
switches0 = [True] #Initial switches
#Create an Assimulo Problem
mod = Explicit_Problem(pendulum, y0, t0, sw0=switches0)
mod.state_events = state_events #Sets the state events to the problem
mod.handle_event = handle_event #Sets the event handling to the problem
mod.name = 'Bouncing Ball in X-Y' #Sets the name of the problem
#Create an Assimulo solver (CVode)
sim = CVode(mod)
#sim = LSODAR(mod)
#sim = RungeKutta34(mod)
#sim.options['verbosity'] = 20 #LOUD
sim.verbosity = 40 #WHISPER
#sim.display_progress = True
#sim.options['minh'] = 1e-4
#sim.options['rtol'] = 1e-3
# #Specifies options
# sim.discr = 'Adams' #Sets the discretization method
# sim.iter = 'FixedPoint' #Sets the iteration method
# sim.rtol = 1.e-8 #Sets the relative tolerance
# sim.atol = 1.e-6 #Sets the absolute tolerance
return sim
def create_model():
def pendulum(t, X, sw):
"""
The ODE to be simulated. The parameter sw should be fixed during
the simulation and only be changed during the event handling.
"""
#X = X.copy()
g = 9.81
x = X[0]
vx = X[2]
vy = X[3]
return np.array([vx, vy, -(np.pi**2)*x, -g, 1.0])
def state_events(t, X, sw):
"""
This is our function that keep track of our events, when the sign
of any of the events has changed, we have an event.
"""
x = X[0]
y = X[1]
return [x - y]
#return np.array([x - y])
def handle_event(solver, event_info):
"""
Event handling. This functions is called when Assimulo finds an event as
specified by the event functions.
"""
state_info = event_info[0] #We are only interested in state events info
if state_info[0] != 0: #Check if the first event function have been triggered
if solver.sw[0]: #If the switch is True the pendulum bounces
X = solver.y
X[1] = X[0] + 1e-3
X[3] = 0.9*(X[2] - X[3])
#solver.sw[0] = not solver.sw[0] #Change event function
#Initial values
phi = 1.0241592; Y0 = -13.0666666; A = 2.0003417; w = np.pi
y0 = [A*np.sin(phi), 1+A*np.sin(phi), A*w*np.cos(phi), Y0 - A*w*np.cos(phi)-1, 0] #Initial states
t0 = 0.0 #Initial time
switches0 = [True] #Initial switches
#Create an Assimulo Problem
mod = Explicit_Problem(pendulum, y0, t0, sw0=switches0)
mod.state_events = state_events #Sets the state events to the problem
mod.handle_event = handle_event #Sets the event handling to the problem
mod.name = 'Bouncing Ball on Sonusoidal Platform' #Sets the name of the problem
#Create an Assimulo solver (CVode)
sim = CVode(mod)
#sim = LSODAR(mod)
sim.options['verbosity'] = 40
#Specifies options
sim.discr = 'Adams' #Sets the discretization method
sim.iter = 'FixedPoint' #Sets the iteration method
sim.rtol = 1.e-8 #Sets the relative tolerance
sim.atol = 1.e-6 #Sets the absolute tolerance
return sim
if state_info[0] != 0: #Check if the first event function has been triggered
if solver.sw[0]: #If the switch is True the pendulum bounces
solver.y[1] = -0.9*solver.y[1] #Change the velocity and lose energy
solver.sw[0] = not solver.sw[0] #Change event function
#Initial values
y0 = [N.pi/2.0, 0.0] #Initial states
t0 = 0.0 #Initial time
switches0 = [True] #Initial switches
#Create an Assimulo Problem
mod = Explicit_Problem(pendulum, y0, t0, sw0=switches0)
mod.state_events = state_events #Sets the state events to the problem
mod.handle_event = handle_event #Sets the event handling to the problem
mod.name = 'Pendulum with events' #Sets the name of the problem
#Create an Assimulo solver (CVode)
sim = CVode(mod)
#Specifies options
sim.discr = 'Adams' #Sets the discretization method
sim.iter = 'FixedPoint' #Sets the iteration method
sim.rtol = 1.e-8 #Sets the relative tolerance
sim.atol = 1.e-6 #Sets the absolute tolerance
def handle_result(self, solver, t, y):
if t < self.t_cutoff:
Explicit_Problem.handle_result(self, solver, t, y)
import numpy
import math
from assimulo.problem import Explicit_Problem
from assimulo.solvers import CVode
import matplotlib.pyplot as plt
def rhs(t,y):
k = 1000
L = k*(math.sqrt(y[0]**2+y[1]**2)-1)/math.sqrt(y[0]**2+y[1]**2)
result = numpy.array([y[2],y[3],-y[0]*L,-y[1]*L-1])
return result
t0 = 0
y0 = numpy.array([0.8,-0.8,0,0])
model = Explicit_Problem(rhs,y0,t0)
model.name = 'task1'
sim = CVode(model)
sim.atol=numpy.array([1,1,1,1])*1e-5
sim.rtol=1e-6
sim.maxord=3
#sim.discr='BDF'
#sim.iter='Newton'
tfinal = 70
(t,y) = sim.simulate(tfinal)
#sim.plot()
def run_example(with_plots=True):
"""
This example show how to use Assimulo and CVode for simulating sensitivities
for initial conditions.::
dy1/dt = -(k01+k21+k31)*y1 + k12*y2 + k13*y3 + b1
dy2/dt = k21*y1 - (k02+k12)*y2
dy3/dt = k31*y1 - k13*y3
y1(0) = p1, y2(0) = p2, y3(0) = p3
p1=p2=p3 = 0
See http://sundials.2283335.n4.nabble.com/Forward-sensitivities-for-initial-conditions-td3239724.html
"""
def f(t, y, p):
y1,y2,y3 = y
k01 = 0.0211
k02 = 0.0162
k21 = 0.0111
k12 = 0.0124
k31 = 0.0039
k13 = 0.000035
b1 = 49.3
yd_0 = -(k01+k21+k31)*y1+k12*y2+k13*y3+b1
yd_1 = k21*y1-(k02+k12)*y2
yd_2 = k31*y1-k13*y3
return N.array([yd_0,yd_1,yd_2])
#The initial conditions
y0 = [0.0,0.0,0.0] #Initial conditions for y
p0 = [0.0, 0.0, 0.0] #Initial conditions for parameters
yS0 = N.array([[1,0,0],[0,1,0],[0,0,1.]])
#Create an Assimulo explicit problem
exp_mod = Explicit_Problem(f, y0, p0=p0)
#Sets the options to the problem
exp_mod.yS0 = yS0
#Create an Assimulo explicit solver (CVode)
exp_sim = CVode(exp_mod)
#Sets the paramters
exp_sim.iter = 'Newton'
exp_sim.discr = 'BDF'
exp_sim.rtol = 1e-7
exp_sim.atol = 1e-6
exp_sim.pbar = [1,1,1] #pbar is used to estimate the tolerances for the parameters
exp_sim.continuous_output = True #Need to be able to store the result using the interpolate methods
exp_sim.sensmethod = 'SIMULTANEOUS' #Defines the sensitvity method used
exp_sim.suppress_sens = False #Dont suppress the sensitivity variables in the error test.
#Simulate
t, y = exp_sim.simulate(400) #Simulate 400 seconds
#Basic test
nose.tools.assert_almost_equal(y[-1][0], 1577.6552477, 5)
nose.tools.assert_almost_equal(y[-1][1], 611.9574565, 5)
nose.tools.assert_almost_equal(y[-1][2], 2215.88563217, 5)
nose.tools.assert_almost_equal(exp_sim.p_sol[0][1][0], 1.0)
#Plot
if with_plots:
P.figure(1)
P.subplot(221)
P.plot(t, N.array(exp_sim.p_sol[0])[:,0],
t, N.array(exp_sim.p_sol[0])[:,1],
t, N.array(exp_sim.p_sol[0])[:,2])
P.title("Parameter p1")
P.legend(("p1/dy1","p1/dy2","p1/dy3"))
P.subplot(222)
P.plot(t, N.array(exp_sim.p_sol[1])[:,0],
t, N.array(exp_sim.p_sol[1])[:,1],
t, N.array(exp_sim.p_sol[1])[:,2])
P.title("Parameter p2")
P.legend(("p2/dy1","p2/dy2","p2/dy3"))
P.subplot(223)
P.plot(t, N.array(exp_sim.p_sol[2])[:,0],
t, N.array(exp_sim.p_sol[2])[:,1],
t, N.array(exp_sim.p_sol[2])[:,2])
P.title("Parameter p3")
P.legend(("p3/dy1","p3/dy2","p3/dy3"))
P.subplot(224)
P.plot(t, y)
P.show()
def simulate(self, Tend, nIntervals, gridWidth):
# define assimulo problem:(has to be done here because of the starting value in Explicit_Problem
solver = Explicit_Problem(self.rhs, self.y0)
''' *******DELETE LATER '''''''''
# problem.handle_event = handle_event
# problem.state_events = state_events
# problem.init_mode = init_mode
solver.handle_result = self.handle_result
solver.name = 'Simple Explicit Example'
simulation = CVode(solver) # Create a RungeKutta34 solver
# simulation.inith = 0.1 #Sets the initial step, default = 0.01
# 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 = 0
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
# Create Solver and set settings
# noRootFunctions = np.size(self.state_events(self.t0, np.array(self.y0)))
# solver = sundials.CVodeSolver(RHS = self.f, ROOT = self.rootf, SW = [False]*noRootFunctions,
# abstol = self.atol, reltol = self.rtol)
# solver.settings.JAC = None #Add user-dependent jacobian here
'''Initialize problem '''
# solver.init(self.t0, self.y0)
self.handle_result(self.t0, self.y0)
nextTimeEvent = self.time_events(self.t0, self.y0)
self.t_cur = self.t0
self.y_cur = self.y0
state_event = False
#
#
if gridWidth <> None:
nOutputIntervals = int((Tend - self.t0) / gridWidth)
else:
nOutputIntervals = nIntervals
# Define step length depending on if gridWidth or nIntervals has been chosen
if nOutputIntervals > 0:
# Last point on grid (does not have to be Tend:)
if(gridWidth <> None):
dOutput = gridWidth
else:
dOutput = (Tend - self.t0) / nIntervals
else:
dOutput = Tend
outputStepCounter = long(1)
nextOutputPoint = min(self.t0 + dOutput, Tend)
while self.t_cur < Tend:
# Time-Event detection and step time adjustment
if nextTimeEvent is None or nextOutputPoint < nextTimeEvent:
time_event = False
self.t_cur = nextOutputPoint
else:
time_event = True
self.t_cur = nextTimeEvent
try:
# #Integrator step
# self.y_cur = solver.step(self.t_cur)
# self.y_cur = np.array(self.y_cur)
# state_event = False
# Simulate
# take a step to next output point:
t_new, y_new = simulation.simulate(self.t_cur) # 5, 10) #5, 10 self.t_cur self.t_cur 2. argument nsteps Simulate 5 seconds
# t_new, y_new are both vectors of the time and states at t_cur and all intermediate
# points before it! So take last values:
self.t_cur = t_new[-1]
self.y_cur = y_new[-1]
state_event = False
except:
import sys
print "Unexpected error:", sys.exc_info()[0]
# except CVodeRootException, info:
# self.t_cur = info.t
# self.y_cur = info.y
# self.y_cur = np.array(self.y_cur)
# time_event = False
# state_event = True
#
#
# Depending on events have been detected do different tasks
if time_event or state_event:
event_info = [state_event, time_event]
if not self.handle_event(self, event_info):
break
solver.init(self.t_cur, self.y_cur)
nextTimeEvent = self.time_events(self.t_cur, self.y_cur)
# If no timeEvent happens:
if nextTimeEvent <= self.t_cur:
nextTimeEvent = None
if self.t_cur == nextOutputPoint:
# Write output if not happened before:
if not time_event and not state_event:
self.handle_result(nextOutputPoint, self.y_cur)
outputStepCounter += 1
nextOutputPoint = min(self.t0 + outputStepCounter * dOutput, Tend)
self.finalize()
return np.array([y1,y2,y3,y4])
return f
#pend_mod=Explicit_Problem(f, y0=np.array([1, 1, 0, 0] ))
#pend_mod.problem_name='Nonlinear Pendulum'
#Define an explicit solver
#exp_sim = CVode(pend_mod) #Create a BDF solver
#t, y = exp_sim.simulate(1)
rhs = getRHS(100)
pend_mod=Explicit_Problem(rhs, y0=np.array([2, 2, 0, 0]))
pend_mod.problem_name='Nonlinear Pendulum'
#Define an explicit solver
solver = CVode(pend_mod)
time = 10
t1,y1 = solver(time)
P.plot(y1[:,0],y1[:,1])
P.grid()
P.show()
P.title('CVode for k = 1, time = 30s')
P.xlabel('X-pos')
P.ylabel('Y-pos')
import numpy as N
import pylab as P
from assimulo.problem import Explicit_Problem #Imports the problem formulation from Assimulo
from assimulo.solvers.sundials import CVode #Imports the solver CVode from Assimulo
def rhs(t,y):
A =N.array([[0,1],[-2,-1]])
yd=N.dot(A,y)
return yd
y0=N.array([1.0,1.0])
t0=0.0
model = Explicit_Problem(rhs, y0, t0) #Create an Assimulo problem
model.name = 'Linear Test ODE' #Specifies the name of problem (optional)
sim = CVode(model)
tfinal = 10.0 #Specify the final time
t, y = sim.simulate(tfinal) #Use the .simulate method to simulate and provide the final time
#Plots the result
P.plot(t,y)
P.show()
def __init__(self, new_rhs, y0, rhs_jac=None):
Explicit_Problem.__init__(self, y0=y0)
self.rhs = new_rhs
self.rhs_jac = rhs_jac