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