plt.savefig('vib_%d_%d_u.pdf' % (timesteps_per_period, num_periods))
plt.savefig('vib_%d_%d_u.eps' % (timesteps_per_period, num_periods))
#f = RHS(b=0.4, A_F=1, w_F=2)
f = RHS(b=0.4, A_F=0, w_F=2)
f = RHS(b=0.4, A_F=1, w_F=np.pi)
f = RHS(b=0.4, A_F=20,
w_F=2 * np.pi) # qualitatively wrong FE, almost ok BE, smaller T
#f = RHS(b=0.4, A_F=20, w_F=0.5*np.pi) # cool, FE almost there, BE good
# Define different sets of experiments
solvers_theta = [
odespy.ForwardEuler(f),
# Implicit methods must use Newton solver to converge
odespy.BackwardEuler(f, nonlinear_solver='Newton'),
odespy.CrankNicolson(f, nonlinear_solver='Newton'),
]
solvers_RK = [odespy.RK2(f), odespy.RK4(f)]
solvers_accurate = [
odespy.RK4(f),
odespy.CrankNicolson(f, nonlinear_solver='Newton'),
odespy.DormandPrince(f, atol=0.001, rtol=0.02)
]
solvers_CN = [odespy.CrankNicolson(f, nonlinear_solver='Newton')]
if __name__ == '__main__':
timesteps_per_period = 20
solver_collection = 'theta'
num_periods = 1
L = 0.5
beta = 8.2E-5
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 = 600 # 10 min
import odespy
solver = odespy.BackwardEuler(rhs, f_is_linear=True, jac=K)
solver = odespy.ThetaRule(rhs, f_is_linear=True, jac=K, theta=0.5)
solver.set_initial_condition(U_0)
T = 1 * 60 * 60
N_t = int(round(T / dt))
time_points = linspace(0, T, N_t + 1)
u, t = solver.solve(time_points)
# Make movie
import os
os.system('rm tmp_*.png')
import matplotlib.pyplot as plt
import time
plt.ion()
y = u[0, :]
lines = plt.plot(x, y)
f_kwargs = dict(L=L, beta=1, x=x)
u = zeros(N + 1)
U_0 = zeros(N + 1)
U_0[0] = s(0)
U_0[1:] = 283
import odespy
solvers = {
'FE':
odespy.ForwardEuler(rhs, f_kwargs=f_kwargs),
'BE':
odespy.BackwardEuler(rhs,
f_is_linear=True,
jac=K,
f_kwargs=f_kwargs,
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),
def f(u, t):
return -a * u
I = 1
a = 2
T = 6
dt = float(sys.argv[1]) if len(sys.argv) >= 2 else 0.75
Nt = int(round(T / dt))
t_mesh = np.linspace(0, Nt * dt, Nt + 1)
solvers = [
odespy.RK2(f),
odespy.RK3(f),
odespy.RK4(f),
odespy.BackwardEuler(f, f_is_linear=True, jac=lambda u, t: -a)
]
# (If f_is_linear is not specified in BackwardEuler, a
# nonlinear solver is invoked and this must be Newton
# (nonlinear_solver='Newton') since the default choice,
# nonlinear_solver='Picard', diverges in this problem.)
legends = []
for solver in solvers:
solver.set_initial_condition(I)
u, t = solver.solve(t_mesh)
plt.plot(t, u)
plt.hold('on')
legends.append(solver.__class__.__name__)
problem = Problem(c=1, Theta=pi / 4)
atol = 1E-7
rtol = 1E-5
adams_or_bdf = 'bdf'
import odespy
solvers = [
odespy.AdamsBashMoulton2(problem),
odespy.AdamsBashMoulton3(problem),
odespy.AdamsBashforth2(problem),
odespy.AdamsBashforth3(problem),
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),
