Exercise_set7_programming_exercises

Transcription

1 Exercise_set7_programming_exercises May 13, Part 1(d) We start by defining some function that will be useful: The functions defining the system, and the Hamiltonian and angular momentum. In [1]: %matplotlib inline import matplotlib import numpy as np import numpy.linalg as la import matplotlib.pyplot as plt # In the following, think of p and x as NumPy arrays of length 2. def f1(p,x): return p def f2(p,x): r = la.norm(x, ord=2) return -x/r**3 def H(p,x): pn = la.norm(p, ord=2) r = la.norm(x, ord=2) return 0.5*pn**2-1./r def L(p,x): return np.cross(x,p) We then implement functions for one time step of the Symplectic Euler method, and a function for doing a full simulation. In [2]: # Symplectic Euler: def sympeuler(pn, xn, h): p_next = pn + h * f2(pn,xn) # Notice that we use the updated value p_next when updating x x_next = xn + h * f1(p_next,xn) return p_next, x_next 1

2 def simulate_2bp(x0, p0, T, N): # Initialize results: x = np.zeros( (N,2), dtype=float) x[0] = x0 p = np.zeros( (N,2), dtype=float) p[0] = p0 # Set h: h = T/N # Do time steps: for i in range(n-1): p[i+1], x[i+1] = sympeuler(p[i], x[i], h) return p, x We define similar functions for the forward Euler method: In [3]: def fwdeuler(pn, xn, h): p_next = pn + h*f2(pn,xn) x_next = xn + h*f1(pn, xn) return p_next, x_next def simulate_2bp_fe(x0, p0, T, N): # Initialize results: x = np.zeros( (N,2), dtype=float) x[0] = x0 p = np.zeros( (N,2), dtype=float) p[0] = p0 # Set h: h = T/N # Do time steps: for i in range(n-1): p[i+1], x[i+1] = fwdeuler(p[i], x[i], h) return p, x Finally, we set the parameter values and do the simulations: In [4]: # Set some parameters: T = 200. N = 4000 e = 0.5 x0 = np.array( [1-e, 0.] ) p0 = np.array( [0., np.sqrt((1+e)/(1-e))] ) 2

3 # Do the simulation: p, x = simulate_2bp(x0, p0, T, N) pe, xe = simulate_2bp_fe(x0, p0, T, 100*N) The post-processing and plotting is fairlig straightforward: In [5]: # Calculate H and L: Eh = np.zeros(n, dtype=float) Lh = np.zeros(n, dtype=float) for i in range(n): Lh[i] = L(p[i], x[i]) Eh[i] = H(p[i], x[i]) t = np.linspace(0., T, N, endpoint=false) # Initialize figure: fig = plt.figure() # Plot symplectic Euler solution: ax = fig.add_subplot(2,2,1) ax.set_title("symplectic Euler") # I set a small linewdith to keep the plot from getting too cluttered. # (the 'k-' argument just says the the plotter should draw a black line) ax.plot(x[:,0], x[:,1], 'k-', linewidth=0.2) # Plot Forward Euler: ax = fig.add_subplot(2,2,2) ax.set_title("forward Euler") ax.plot(xe[:,0], xe[:,1], 'k-', linewidth=0.2) # Plot numerical energy: ax = fig.add_subplot(2,2,3) ax.set_title("$h(p,x)$") ax.plot(t,eh) # Plot angular momentum: ax = fig.add_subplot(2,2,4) ax.set_title("$l(p,x)$") ax.plot(t,lh) # Show plot: plt.show() 3

4 From these plots we see that the symplectic Euler method is much better than the Forward Euler method at keeping the numerical solution in orbit, but there is some precession going on. As we already saw in the mandatory assignment, the symplectic Euler method keeps the numerical energy bounded (although not strictly conserved). Finally the angular momentum is exactly conserved, as predicted. 2 Part 2 (a)-(b) In this part we are to solve some nonlinear ODEs numerically using backward Euler s method. In these notes, we ll solve the set of nonlinear equations at each time step using Newton s method, since I hope this approach will be the most instructive. Recall that with Newton s method, we aim to find solutions to the equation g(x) = 0, where x R d, and g : R d R d. Given some iterate x i, we get the next iteration by solving the linearized equation g(x i ) + g(x i )(x x i ) = 0. Solving for x, we get the next iteration as x i+1 = x i ( g(x i )) 1 g(x i ). by In backward Euler, with the previous time step y n R d given, the next time step y n+1 is given y n+1 = y n + h f (y n+1 ), 4

5 which we may rewrite as y n+1 y n h f (y n+1 ) = 0. So we set g(x) = x y n h f (x), in the Newton s method as written above. See then that g(x) = I h f (x). Taking one step of forward Euler as initial guess, the iterative method reads: y (0) n+1 = y n + h f (y n ), which we stop when the relative error y (i+1) n+1 = y (i) n+1 (I h f (y(i) n+1 )) 1 (y (i) n+1 y n h f (y (i) n+1 )), y (i+1) n+1 y(i) n+1 y (i) n+1 < ϵ. In the following implementation, we divide up the work a little bit. First, we implement a function for doing Newton s method, and the we use this function to do one time step of backward Euler. In [6]: def newtons_method(x0, f, df, eps=1e-9, maxiter=1000): """Newton iteration for system of equations. INPUT: x0: NumPy array, initial guess. f, df: Function, and function derivative. eps: Error tolerance (defaults to 1E-9). maxiter: Maximum number of iterations before giving up (defaults to 1000). OUTPUT: Returns the last step of the Newton iterations (whether converged or not). """ x = x0 # Initialize the relative error: gamma = 1. # Iteration counter: counter = 0 while (gamma > eps) and (counter < maxiter): # Update x: x_prev = x x = x - la.solve(df(x), f(x)) # Calculate gamma: gamma = la.norm(x-x_prev)/(la.norm(x_prev)+1e-12) #+1E-12 is just to avoid divid # Update counter: counter += 1 return x def bwdeuler(x, f, df, h): """ Do a time-step of bwd Euler. INPUT: x: Current time step 5

6 f, df: System functions, and derivative""" # Initial guess: x0 = x + h*f(x) # Set identity matrix: I = np.eye(len(x)) # Define functions for Newton iteration: phi = lambda y: y - x - h*f(y) dphi = lambda y: I - h*df(y) # Do Newton iteration: return newtons_method(x0, phi, dphi) We can now make a simulation function: In [7]: def simulate_bwdeuler(x0, f, df, T, N): """Simulation function. INPUT: x0: Initial value (NumPy array). f, df: System function and derivative. T: End time. N: Number of time steps. OUTPUT: Numerical simulation at each time step.""" h = T/N d = len(x0) x = np.zeros( (N, d), dtype=float) x[0] = x0 2.1 Part 2 (a) # Do time steps: for i in range(n-1): x[i+1] = bwdeuler(x[i], f, df, h) return x We now use the previously implemented functions to solve the modified logistic equation. Disclaimer: Because of the use la.solve(... ) in the above Newton s method, all values of x, f(x), and df(x) should be NumPy arrays. In the case of a 1D ODE (as this is), this doesn t make the most sense, but I opted for generality in the code instead of having to make two almost identical Newton methods. In [8]: # Define f(...) and df(...): def f(x): return np.array( [-x[0]*(1.-x[0])*(1-2*x[0])] ) def df(x): return np.array( [[-(1.-x[0])*(1.-2*x[0]) + x[0]*(1.-2*x[0]) + 2*x[0]*(1.-x[0]) ]]) # Set other parameters: T = 10. 6

7 N = 100 t = np.linspace(0., T, N, endpoint=false) # Initialize plot: fig = plt.figure() ax = fig.add_subplot(1,1,1) # Set initial conditions (each row is a separate initial value): x0s = np.linspace(0.,1.,21).reshape( (21,1) ) for x0 in x0s: # Simulate: x = simulate_bwdeuler(x0, f, df, T, N) # Plot: ax.plot(t,x[:,0], 'k-') ax.set_xlabel("$t$") ax.set_ylabel("$x(t)$") plt.show() From these simulations, it looks like x = 0 and x = 1 are stable equilibria, and x = 1 2 is unstable. You are more than welcome to verify this. 7

8 2.2 Part 2 (b) The code for this part is very similar to the last part. In [9]: # Set f(x) and df(x): def f(x): return np.array([ x[0]*(x[1]-2.), x[1]*(1.-x[0])]) def df(x): return np.array( [[ x[1]-2., x[0] ], [ -x[1], 1.-x[0] ]] ) # Set some parameters: T = 10. N = 200 x0 = np.linspace(0., 1., 11) x0s = np.vstack( (x0, 2*x0) ).T # Initialize figure: fig = plt.figure() ax = fig.add_subplot(1,1,1) for x0 in x0s: # Simulate: x = simulate_bwdeuler(x0, f, df, T, N) ax.plot(x[:,0], x[:,1], 'k-', linewidth=0.5) ax.set_xlabel("$x$") ax.set_ylabel("$y$") plt.show() 8

9 In [ ]: 9