Solving Systems of ODEs in Python: From scalar to TOV. MP 10/2011

Transcription

1 Solving Systems of ODEs in Python: From scalar to TOV. MP 10/2011

2 Homework: Integrate a scalar ODE in python y (t) =f(t, y) = 5ty 2 +5/t 1/t 2 y(1) = 1 Integrate the ODE using using the explicit Euler method: y n+1 = y n + hf(t n,y n ) up to t=25 with various fixed step sizes h and record the absolute error e h (h) :=y n y(t n ) y 1 =1 between the numerical approximation and the exact solution at the end of the interval for each step size. Integrate the ODE with the explicit trapezoidal Runge Kutta 2 method k 1 = hf(t n,y n ) k 2 = hf(t n+1,y n + k 1 ) y n+1 = y n (k 1 + k 2 ) as above for various step sizes and compute the absolute error: y(t) =1/t

3 Homework: Integrate a scalar a scalar ODE ODE in python in python Compute a convergence rate for each method: If the error at step n behaves like e n (h) =y n y(t n ) Ch p then halving the step size yields e 2n (h/2) C(h/2) p Thus, the convergence rate can be obtained as p log 2 en (h) e 2n (h/2) Interpret the results! Which method is better? Make your program modular by dividing it into functions that can be reused Bonus: make the program work for integrating a set of different initial conditions at the same time

4 Homework: Integrate a scalar a scalar ODE ODE in python in python Simple Solution import matplotlib.pyplot as plt import numpy as np def EulerStep(u,t,dt,rhs): up = u + dt*rhs(u, t) return up # Asher / Petzold ex. 4.1 def rhs(u,t): return -5*t*u**2 + 5./t - 1./t**2 # now setup parameters, initial data and integrate the ODE t0 = 1.0 tend = 25.0 u = 1. nsteps = 500 dt = (tend-t0) / nsteps sol = np.zeros(nsteps) # to store the solution n=0 t=t0 while n < nsteps: sol[n] = u u = EulerStep(u,t,dt,rhs) n+=1 t+=dt # plot the result ts=np.linspace(t0,tend,nsteps) plt.plot(ts,sol) plt.show()

5 Homework: Integrate a scalar a scalar ODE ODE in python in python Improved Solution (part 1) import matplotlib.pyplot as plt import numpy as np def EulerStep(u,t,dt,rhs): up=u + dt*rhs(u, t) return up def RK2Step(u,t,dt,rhs): k1 = dt*rhs(u,t) k2 = dt*rhs(u + k1, t + dt) up = u + 0.5*(k1 + k2) return up # now setup parameters, initial data # and integrate the ODE def toyint(method, dt): t0 = 1.0 tend = 25.0 u = 1.0 nsteps = int((tend-t0) / dt) sol = [u] n=0 t=t0 while n < nsteps: u = method(u,t,dt,rhs) sol.append(u) n+=1 t+=dt # Asher / Petzold ex. 4.1 def rhs(u,t): return -5*t*u**2 + 5./t - 1./t**2 ts=np.linspace(t0,tend,nsteps) return (ts, sol) def yex(t): return 1./t

6 Homework: Integrate a scalar a scalar ODE ODE in python in python Improved Solution (part 2) def test(method, h): (ti,yi) = toyint(method, h) err = abs(yi[-1] - yex(ti[-1])) (ti2,yi2) = toyint(method, h/2) err2 = abs(yi2[-1] - yex(ti2[-1])) p = np.log2(err / err2) return (err, p) if name == " main ": # now we can import this file as a module without # running 'main', or execute it as a script hlist = [0.2, 0.1, 0.05, 0.02, 0.01, 0.005, 0.002] print 'step h\t Euler error\trate\trk2 error\trate' for h in hlist: (EulerErr, EulerP) = test(eulerstep, h) (RK2Err, RK2P) = test(rk2step, h) print '%.3f\t %.1e\t%.2f \t %.1e\t%.2f' %(h, EulerErr, EulerP, RK2Err, RK2P)

7 Homework: Extension: Integrate a a scalar ODE ODE in in python Implement the classical Runge-Kutta 4 method integrate the example scalar ODE and check the convergence order for it!

8 Homework: Extension: Integrate a a scalar ODE ODE in in python Solution: add RK4Step() function and modify main def RK4Step(u,t,dt,rhs): k1 = dt*rhs(u,t) k2 = dt*rhs(u + 0.5*k1, t + 0.5*dt) k3 = dt*rhs(u + 0.5*k2, t + 0.5*dt) k4 = dt*rhs(u + k3, t + dt) up = u + (k1 + 2*k2 + 2*k3 + k4) / 6.0 return up if name == " main ": hlist = [0.2, 0.1, 0.05, 0.02, 0.01, 0.005, 0.002] print 'step h\t Euler error\trate\trk2 error\trate\trk4 error\trate' for h in hlist: (EulerErr, EulerP) = test(eulerstep, h) (RK2Err, RK2P) = test(rk2step, h) (RK4Err, RK4P) = test(rk4step, h) print '%.3f\t %.1e\t%.2f \t %.1e\t%.2f \t%.1e\t\t%.2f' %(h, EulerErr, EulerP, RK2Err, RK2P, RK4Err, RK4P)

9 Homework: Extension: Integrate a a scalar ODE ODE in in python Result: flux$ python toyint-scalar.py h Euler error rate RK2 error rate RK4 error rate e e e e e e e e e e e e e e e e e e e e e What is happening in the RK4 rate for small h?

10 Homework: Extension: Integrate a a scalar ODE ODE in in python Make this work for vector ODEs using numpy arrays. For now just integrate the scalar ODE with an array of different initial conditions. What changes are necessary in the integrators and integration loop to make sure we do not write into the same memory location for different arrays?

11 Homework: Extension: Integrate a a scalar ODE ODE in in python Integrators unchanged: def RK4Step(u,t,dt,rhs): # pass an array() for u => new arrays get created in the operations k1 = dt*rhs(u,t) # below => k_i are allocated in different memory locations k2 = dt*rhs(u + 0.5*k1, t + 0.5*dt) k3 = dt*rhs(u + 0.5*k2, t + 0.5*dt) k4 = dt*rhs(u + k3, t + dt) up = u + (k1 + 2*k2 + 2*k3 + k4) / 6.0 return up def test(method, h): (ti,yi) = toyint(method, h) err = abs(yi[-1] - yex(ti[-1])) (ti2,yi2) = toyint(method, h/2) err2 = abs(yi2[-1] - yex(ti2[-1])) p = np.log2(err / err2) return (np.min(err), np.min(p)) # err and p are arrays now: choose some # reduction operation to obtain a scalar value # e.g. the worst case: minimum

12 Homework: Extension: Integrate a a scalar ODE ODE in in python Solution array is 2D now def toyint(method, dt): t0 = 1.0 tend = 25.0 u = np.array([1.,.5]) # we pass an array in, so we can later integrate PDEs: # here just two different ICs nsteps = int((tend-t0) / dt) # now we determine the number of steps from the stepsize sol = np.zeros((nsteps,len(u))) # 2d array to store the solution vector for all times n=0 t=t0 sol[0] = u while n < nsteps: n+=1 t+=dt u = method(u,t,dt,rhs) sol[n] = u ts=np.linspace(t0,tend,nsteps) return (ts, sol) # store initial data # update solution array

13 Finally some gravity: Solve the TOV equations for a static spherically symmetric polytropic fluid Metric describing the gravitational field of a spherically star Static equilibrium: Φ=Φ(r) Define the mass function m(r) λ = λ(r) via Tolman-Oppenheimer-Volkoff equations for SS equilibrium stars [B&S sec 1.3] and a polytropic equation of state for the fluid polytropic index total mass-energy density Γ=1+1/n rest-mass density internal energy density per unit rest-mass You need to use the equations for m, P and the polytropic EOS

14 Finally some gravity: Solve the TOV equations for a static spherically symmetric polytropic fluid We have chosen geometric units G=c=1 -- why is this advisable? Start integration at the center of the star by specifying a central pressure or density and vanishing mass: m =0 at. P = P c r =0 ρ = ρ 0 + P/(Γ 1) ρ Use the relation thermodynamics to eliminate which follows from the first law of from the ODE system. Need to regularize the ODEs at the origin: singular terms of the form! Use Taylor expansions / l Hospital s rule. Integrate until the surface of the star: physically we would like to go until p=0, but numerically we will have to stop at some small finite pressure. Compute the total mass as M = Use Runge-Kutta 4 (or experiment with other solvers if you like) R 0 4πr 2 ρdr m/r i Once your code is working and gives sensible results, perform a convergence test; check whether the rate agrees with the expected 4th order rate of RK4.

15 Finally some gravity: Solve the TOV equations for a static spherically symmetric polytropic fluid Consider also the Newtonian limit: In gravitational units has units of length Integrate the TOV equations for a simple reference model K = 100,n=1, Γ=1+1/n, ρ c = You should find a solution close to M =1.4M K n/2 Now for the real physics: compute the equilibrium sequence for n=1 polytropes To do that perform many integrations of the TOV equations with initial mass-energy density ρ c [0, 1.3] and find turning point which is the maximum in the mass-energy you can set the polytropic gas constant to K =1 The turning point should be at P ρ, m(r) r and ρ c =0.420 M =0.164 M(ρ c )