def test_switch_to():
problem = Exponential
solver = odespy.RKFehlberg(problem['f'])
solver.set_initial_condition(problem['u0'])
u, t = solver.solve(problem['time_points'])
solver_new = solver.switch_to(odespy.Lsode)
u2, t2 = solver.solve(problem['time_points'])
diff = np.abs(u - u2).max()
nt.assert_almost_equal(diff, 0, delta=0.1)
def test_terminate():
problem = Exponential
solver = odespy.RKFehlberg(problem['f'])
solver.set_initial_condition(problem['u0'])
u, t = solver.solve(problem['time_points'], terminate=problem['terminate'])
exact_diff = 0.0321206486802586
diff = abs(problem['stop_value'] - u[-1])
print 'Testing RKFehlberg with terminate function',
nt.assert_almost_equal(diff, exact_diff, delta=1E-14)
print '...ok'
def test_switch_to():
problem = Exponential
solver = odespy.RKFehlberg(problem['f'])
solver.set_initial_condition(problem['u0'])
u, t = solver.solve(problem['time_points'])
solver_new = solver.switch_to(odespy.Lsode)
u2, t2 = solver_new.solve(problem['time_points'])
diff = np.abs(u - u2).max()
exact_diff = 0.0000015284633990
print 'Testing switch_to from RKFehlberg to Lsode',
nt.assert_almost_equal(diff, exact_diff, delta=1E-14)
print '...ok'
def test_terminate(self):
for problem in [Exponential, Sine, VanDerPol]:
self._load_problem(problem)
solver = odespy.RKFehlberg(self.f, **self.kwargs)
solver.set_initial_condition(self.u0)
u, t = solver.solve(self.time_points, terminate=self.terminate)
u_stop = u[-1][0] if len(u.shape) == 2 else u[-1]
assert_almost_equal(u_stop,
self.stop_value,
verbose=True,
decimal=1)
def test_f_kwargs(self):
self._load_problem(Exponential)
solver = odespy.RKFehlberg(self.f_with_kwargs,
f_kwargs=self.f_kwargs,
**self.kwargs)
solver.set_initial_condition(self.u0)
u, t = solver.solve(self.time_points)
exact = self.exact(t)
assert_array_almost_equal(\
u, exact,
err_msg='Failed with f_args',
decimal=2, verbose=True)
def test_switch_to(self):
for problem in [Exponential, Sine]:
self._load_problem(problem)
solver = odespy.RKFehlberg(self.f, **self.kwargs)
solver.set_initial_condition(self.u0)
u, t = solver.solve(self.time_points)
solver_new = solver.switch_to(odespy.Lsode)
u_new, t_new = solver_new.solve(self.time_points)
assert_array_almost_equal(\
u, u_new,
err_msg='''
Failed for switch from RKFehlberg to Lsode with problem %s''' \
% self.help,
decimal=2, verbose=False)
def get_solver(self, func):
"""
Returns the solver method from odespy package.
Args:
func: function
function with ODE system.
Returns: an instance of odeSolver
"""
if self.solverMethod is solverMethod.LSODA:
solver = odespy.Lsoda(func)
elif self.solverMethod is solverMethod.LSODAR:
solver = odespy.Lsodar(func)
elif self.solverMethod is solverMethod.LSODE:
solver = odespy.Lsode(func)
elif self.solverMethod is solverMethod.HEUN:
solver = odespy.Heun(func)
elif self.solverMethod is solverMethod.EULER:
solver = odespy.Euler(func)
elif self.solverMethod is solverMethod.RK4:
solver = odespy.RK4(func)
elif self.solverMethod is solverMethod.DORMAN_PRINCE:
solver = odespy.DormandPrince(func)
elif self.solverMethod is solverMethod.RKFehlberg:
solver = odespy.RKFehlberg(func)
elif self.solverMethod is solverMethod.Dopri5:
solver = odespy.Dopri5(func)
elif self.solverMethod is solverMethod.Dop853:
solver = odespy.Dop853(func)
elif self.solverMethod is solverMethod.Vode:
solver = odespy.Vode(func)
elif self.solverMethod is solverMethod.AdamsBashforth2:
solver = odespy.AdamsBashforth2(func, method='bdf')
elif self.solverMethod is solverMethod.Radau5:
solver = odespy.Radau5(func)
elif self.solverMethod is solverMethod.AdamsBashMoulton2:
solver = odespy.AdamsBashMoulton2(func)
# update default parameters
solver.nsteps = SolverConfigurations.N_STEPS
solver.atol = SolverConfigurations.ABSOLUTE_TOL
solver.rtol = SolverConfigurations.RELATIVE_TOL
return solver
def test_terminate():
problem = Exponential
solver = odespy.RKFehlberg(problem['f'])
solver.set_initial_condition(problem['u0'])
u, t = solver.solve(problem['time_points'], terminate=problem['terminate'])
nt.assert_almost_equal(u[-1], problem['stop_value'], delta=0.5)
beta = 1
N = 40
x = linspace(0, L, N + 1)
dx = x[1] - x[0]
u = zeros(N + 1)
U_0 = zeros(N + 1)
U_0[0] = s(0)
U_0[1:] = 283
dt = dx**2 / (2 * beta)
print 'stability limit:', dt
dt *= 100
import odespy
#solver = odespy.RKFehlberg(rhs, rtol=1E-6, atol=1E-8)
solver = odespy.RKFehlberg(rhs, rtol=1E-3, atol=1E-8)
solver.set_initial_condition(U_0)
T = 1.2
N_t = int(round(T / float(dt)))
time_points = linspace(0, T, N_t + 1)
u, t = solver.solve(time_points)
# Check how many time steps required by adaptive vs
# fixed-step methods
if hasattr(solver, 't_all'):
print '# time steps:', len(solver.t_all)
plt.figure()
plt.plot(array(solver.t_all[1:]) - array(solver.t_all[:-1]))
plt.title('Evolution of the time step in %s' % solver.__class__.__name__)
plt.savefig('tmp.png')
plt.savefig('tmp.pdf')
import odespy, numpy, time
w = 2 * numpy.pi
n = 600 # no of periods
r = 40 # resolution of each period
tp = numpy.linspace(0, n, n * r + 1)
solvers = [
odespy.Vode(f,
complex_valued=True,
atol=1E-7,
rtol=1E-6,
adams_or_bdf='adams'),
odespy.RK4(f, complex_valued=True),
odespy.RKFehlberg(f, complex_valued=True, atol=1E-7, rtol=1E-6)
]
cpu = []
for solver in solvers:
solver.set_initial_condition(1 + 0j)
t0 = time.clock()
solver.solve(tp)
t1 = time.clock()
cpu.append(t1 - t0)
# Compare solutions at the end point:
exact = numpy.exp(1j * w * tp).real[-1]
min_cpu = min(cpu)
cpu = [c / min_cpu for c in cpu] # normalize
print 'Exact: u(%g)=%g' % (tp[-1], exact)
for solver, cpu_time in zip(solvers, cpu):
jac_kwargs=f_kwargs),
'B2':
odespy.Backward2Step(rhs,
f_is_linear=True,
jac=K,
f_kwargs=f_kwargs,
jac_kwargs=f_kwargs),
'theta':
odespy.ThetaRule(rhs,
f_is_linear=True,
jac=K,
theta=0.5,
f_kwargs=f_kwargs,
jac_kwargs=f_kwargs),
'RKF':
odespy.RKFehlberg(rhs, rtol=1E-6, atol=1E-8, f_kwargs=f_kwargs),
'RKC':
odespy.RKC(rhs, rtol=1E-6, atol=1E-8, f_kwargs=f_kwargs,
jac_constant=True),
}
try:
method = sys.argv[1]
dt = float(sys.argv[2])
T = float(sys.argv[3])
except IndexError:
method = 'FE'
dx = x[1] - x[0]
dt = dx**2 / (2 * beta) # Forward Euler limit
print 'Forward Euler stability limit:', dt
T = 1.2
odespy.AdamsBashforth4(problem),
odespy.AdaptiveResidual(problem, solver='Euler'),
odespy.Backward2Step(problem),
odespy.BackwardEuler(problem),
odespy.Dop853(problem, rtol=rtol, atol=atol),
odespy.Dopri5(problem, rtol=rtol, atol=atol),
odespy.Euler(problem),
odespy.Heun(problem),
odespy.Leapfrog(problem),
odespy.LeapfrogFiltered(problem),
odespy.MidpointImplicit(problem),
odespy.MidpointIter(problem, max_iter=10, eps_iter=1E-7),
odespy.RK2(problem),
odespy.RK3(problem),
odespy.RK4(problem),
odespy.RKFehlberg(problem, rtol=rtol, atol=atol),
odespy.SymPy_odefun(problem),
odespy.ThetaRule(problem),
odespy.Trapezoidal(problem),
odespy.Vode(problem, rtol=rtol, atol=atol, adams_or_bdf=adams_or_bdf),
]
theta_exact = lambda t: problem.Theta * numpy.cos(sqrt(problem.c) * t)
import sys, time
try:
num_periods = int(sys.argv[1])
except IndexError:
num_periods = 30 # default
T = num_periods * problem.period # final time
