Ordinary Differential Equations

Transcription

1 Ordinary Differential Equations MCS 507 Lecture 30 Mathematical, Statistical and Scientific Software Jan Verschelde, 31 October 2011

2 Ordinary Differential Equations 1 2 3

3 a simple pendulum Imagine a sphere attached to a massless rod oscilating back and forth due to gravity: where t is time, starting at 0; θ (t) + α sin(θ(t)) = 0, θ is the angle of deviation the rod makes from its (vertical) position at rest; α = g/l, where g is the gravitational constant and L is the length of the rod. page 3

4 first order equations Introducing an auxiliary variable v(t) = θ (t), we transform θ (t) + α sin(θ(t)) = 0 into a system of first order : θ (t) = v(t) v (t) = α sin(θ(t)) θ with initial conditions: θ(0) = π/6 and v(0) = 0. page 4

5 forward We use the definition θ θ(t + h) θ(t) (t) = lim h 0 h to discretize the time domain with step size t. At t = t k, we approximate θ(t k ) θ k and θ(t k+1 ) θ k+1 for and t k+1 = t k + t. So θ (t) = v(t) is approximated by θ k+1 θ k = v k. t Then we compute θ k+1 = θ k + tv k. Similarly, v (t) = α sin(θ(t)) is approximated by v k+1 = v k α t sin(θ k ). page 5

6 plotting the evolution page 6

7 programming the import scipy as sp import matplotlib.pyplot as plt def pendulum(t,n,theta0,v0,alpha): Return the motion (theta, v, t) of a pendulum, governed by the ODE: theta (t) + alpha*sin(theta(t)) = 0, where the parameters are T : time t ranges from 0 to T, n : the number of time steps, theta0 : angle at t = 0, v0 : velocity at t = 0, alpha : value for the parameter. page 7

8 the code in pendulum dt = T/float(n) t = sp.linspace(0,t,n+1) v = sp.zeros(n+1) theta = sp.zeros(n+1) v[0] = v0 theta[0] = theta0 for k in range(n): theta[k+1] = theta[k] + dt*v[k] v[k+1] = v[k] - alpha*dt*sp.sin(theta[k+1]) return theta, v, t page 8

9 the constants def test_values(): Returns values for the input data: T, n, theta0, v0, and alpha. theta0 = sp.pi/6 n = 1000 T = 10 v0 = 0 alpha = 5 return T, n, theta0, v0, alpha page 9

10 the function main def main(): Defines the test values and computes the trajectory of the pendulum. T,n,p0,v0,a = test_values() theta,v,t = pendulum(t,n,p0,v0,a) f = plt.figure() f.add_subplot(211) plt.plot(t,theta) plt.title( angle as function of time ) f.add_subplot(212) plt.plot(t,v,label= velocity(t) ) plt.title( velocity as function of time ) plt.show() page 10

11 Ordinary Differential Equations 1 2 3

12 calling ODEPACK do from.odepack import odeint then help(odeint) shows odeint(func, y0, t,...) Solve a system of ordinary using lsoda from the FORTRAN library odepack. Solves the initial value problem for stiff or non-stiff systems of first order ode-s:: dy/dt = func(y,t0,...) where y can be a vector. ODEPACK is a FORTRAN77 library which implements Alan Hindmarsh s solvers for ordinary, available at page 12

13 defining the right hand side import scipy as sp import matplotlib.pyplot as plt from.odepack import odeint def f(y,t): Is the right hand side of the ODE dy/dt = f(y,t). r = sp.array([0,0],float) r[0] = y[1] r[1] = -5.0*sp.sin(y[0]) return r page 13

14 the function main def main(): Computes the motion of a pendulum, governed by the ODE: theta (t) + alpha*sin(theta(t)) = 0, T = 10; n = 1000 theta0 = sp.pi/6; v0 = 0 tspan = sp.linspace(0,t,n+1) initc = sp.array([theta0,v0]) y = odeint(f,initc,tspan) theta = y[:,0] v = y[:,1] then plot (tspan,theta) and (tspan,v). page 14

15 Ordinary Differential Equations 1 2 3

16 Consider three bodies with masses m 1, m 2, m 3 with positions (x 1 (t), y 1 (t)), (x 2 (t), y 2 (t)), (x 3 (t), y 3 (t)). For the first body: d 2 x 1 (t) dt 2 d 2 y 1 (t) dt 2 =... m 2 (x 1 (t) x 2 (t)) = ( (x1 (t) x 2 (t)) 2 + (y 1 (t) y 2 (t)) 2) 3/2 m 3 (x 1 (t) x 3 (t)) ( (x1 (t) x 3 (t)) 2 + (y 1 (t) y 3 (t)) 2) 3/2 page 16

17 problem With u 1 (t) and v 1 (t), the velocities of x 1 (t) and y 1 (t): dx 1 (t) dt du 1 (t) dt dy 1 (t) dt dv 1 (t) dt = u 1 (t) =... = v 1 (t) =... Adding the equations for the other two bodies, we get 12 first order. page 17

18 the figure eight page 18

19 Ordinary Differential Equations 1 2 3

20 defining the system import scipy as sp import matplotlib.pyplot as plt from.odepack import odeint def f(z,t): z is a vector with 12 entries ordered in blocks of 4: x[k](t),x [k](t),y[k](t),y [k](t) for k = 1,2,3. L = [0 for k in xrange(12)] r = sp.array(l,float) page 20

21 relabeling # take three equal masses m = [1, 1, 1] # relabel input vector z x1 = z[0]; u1 = z[1]; y1 = z[2]; v1 = z[3] x2 = z[4]; u2 = z[5]; y2 = z[6]; v2 = z[7] x3 = z[8]; u3 = z[9]; y3 = z[10]; v3 = z[11] # u and v are first derivatives of x and y r[0] = u1; r[2] = v1 r[4] = u2; r[6] = v2 r[8] = u3; r[10] = v3 page 21

22 computing distances # compute squared distances dx12 = x1 - x2; sdx12 = dx12**2 dx13 = x1 - x3; sdx13 = dx13**2 dx23 = x2 - x3; sdx23 = dx23**2 dy12 = y1 - y2; sdy12 = dy12**2 dy13 = y1 - y3; sdy13 = dy13**2 dy23 = y2 - y3; sdy23 = dy23**2 # denominators d12 = (sdx12 + sdy12)**1.5 d13 = (sdx13 + sdy13)**1.5 d23 = (sdx23 + sdy23)**1.5 page 22

23 assigning the result # righthandside for second order r[1] = - m[1]*dx12/d12 - m[2]*dx13/d13; r[3] = - m[1]*dy12/d12 - m[2]*dy13/d13; r[5] = - m[0]*(-dx12)/d12 - m[2]*dx23/d23; r[7] = - m[0]*(-dy12)/d12 - m[2]*dy23/d23; r[9] = - m[0]*(-dx13)/d13 - m[1]*(-dx23)/d23; r[11] = - m[0]*(-dy13)/d13 - m[1]*(-dy23)/d23; return r page 23

24 the function main def main(): Plots the trajectories of 3 equal masses forming a figure 8. # initial positions ip1 = [ , ] ip2 = [-ip1[0], -ip1[1]]; ip3 = [0, 0] # initial velocities iv3 = [ , ] iv2 = [-iv3[0]/2, -iv3[1]/2]; iv1 = iv2 # input for initial righthandside vector initz = [ip1[0], iv1[0], ip1[1], iv1[1], \ ip2[0], iv2[0], ip2[1], iv2[1], \ ip3[0], iv3[0], ip3[1], iv3[1]] page 24

25 solving the problem T = 2*sp.pi/3; n = 1000 tspan = sp.linspace(0,t,n+1) z = odeint(f,initz,tspan) # extracting the trajectories x1 = z[:,0]; y1 = z[:,2] x2 = z[:,4]; y2 = z[:,6] x3 = z[:,8]; y3 = z[:,10]; # plotting the trajectories fig = plt.figure() plt.plot(x1,y1, r,x2,y2, g,x3,y3, b ) plt.show() page 25

26 Ordinary Differential Equations 1 2 3

27 the tractrix problem A tractor is connected to a trailer by a rigid bar of unit length. The tractor moves in a circle. The path of the trailer is the solution of a system of ordinary. Generalization: trailer is predator, tractor is prey. page 27

28 tractor, trailer, and bar page 28

29 the model Given are (x 1 (t), x 2 (t)) defining the path of the tractor and L is the length of the rigid bar. Wanted: (y 1 (t), y 2 (t)), the path of the trailer. The velocity vector of the trailer is parallel to the direction of the bar: ( y 1 y 2 ) ( y1 x = λ 1 y 2 x 2 ), λ > 0. page 29

30 the ODE system The velocity vector of the trailer is the projection of the velocity vector of the tractor onto the direction of the bar: u = (y 1 x 1, y 2 x 2 ) (y 1 x 1, y 2 x 2 ) and v = (x 1, x 2 ), we compute the projection of the velocity vector as (v T u)u. Then the system of first-order equation that defines the path of the trailer is given by ( ) y 1 y 2 = (v T u)u. with u the normalized vector of the direction of the bar and v the velocity vector of the tractor. page 30

31 Ordinary Differential Equations 1 2 3

32 the tractor import scipy as sp import numpy as np import matplotlib.pyplot as plt from.odepack import odeint def tractor(t): Returns the position (x,y) and velocity vector (u,v) for the tractor at time t. x = sp.cos(t); y = sp.sin(t) u = -sp.sin(t); v = sp.cos(t) return x,y,u,v page 32

33 def trailer(y,t): Defines the right hand side of the system for the trailer. r = np.array([0,0],float) x1, x2, x1v, x2v = tractor(t) r[0] = y[0] - x1 r[1] = y[1] - x2 r = r/np.linalg.norm(r) d = x1v*r[0] + x2v*r[1] r = d*r return r the trailer page 33

34 solving the IVP def main(): Defines the setup for the system for the trailer and solves it. T = 20; n = 100 tspan = sp.linspace(0,t,n+1) initc = sp.array([2,0]) path = odeint(trailer,initc,tspan) x = path[:,0]; y = path[:,1] x1, x2, x1v, x2v = tractor(tspan) fig = plt.figure() plt.plot(x1,x2, r,x,y, g ) for i in xrange(0,n,6): plt.plot(sp.array([x1[i],x[i]]), \ sp.array([x2[i],y[i]]), b ) plt.show() page 34

35 Summary + Exercises SciPy.integrate exports odeint() of odepack. 1 Extend the model for the so it works for any number of bodies. 2 Instead of odeint() for the planar 3-body problem, write code for the forward. For which value(s) of the step size do you get the figure eight? 3 Make an animation of the trajectories of tractor, trailer, and the moving bar. page 35

36 more exercises 4 Solving y = s(t)w where s(t) is the speed and w the normalized direction vector of a predator chasing a prey gives in y the coordinates of the predator. Set up a model for a prey to move in a straight line and let s(t) be a large enough constant so the prey gets caught. Plot the trajectories of prey and predator. 5 Read the documentation about solving ODEs in Sage and use Sage to plot the trajectories either for the figure eight planar 3-body or the tractrix problem. Homework due Friday 18 November at 10AM: Assignments 3, 4, 1, 2, 3, 1, 4, 2, 3, 1 of lectures 13, 14, 15, 16, 17, 18, 21, 22, 23, 24, respectively. page 36