Computational Physics HW2

Transcription

1 Computational Physics HW2 Luke Bouma July 27, Plotting experimental data 1.1 Plotting sunspots.txt in Python: The figure above is the output from from numpy import l o a d t x t data = l o a d t x t ( sunspots. txt, f l o a t ) time = data [ :, 0 ] sunspotn = data [ :, 1 ] p l t. x l a b e l ( Time [ month #] ) p l t. y l a b e l ( Number o f sunspots ) 1

2 p l t. p l o t ( time, sunspotn ) 1.2 Modifying the program to display the first 1000 data points: Where the only output lines that were changed are: time = data [ 0 : , 0 ] sunspotn = data [ 0 : , 1 ] 1.3 Calculating running average of the data. Define the running average to be Y k = 1 2r r m= r y k+m, where r = 5 and y k are the sunspot numbers. This wound up being a bit messier than I wanted, but it still makes good sense: #Import from numpy import loadtxt, sum, zeros, s i z e data = l o a d t x t ( sunspots. txt, f l o a t ) time = data [ :, 0 ] sunspotn = data [ :, 1 ] 2

3 #Smoothing r = 5 Y = z e r o s ( s i z e ( sunspotn ) ) for k in range ( s i z e ( sunspotn ) ) : i f k < 5 or k > 3100: Y[ k ] = sunspotn [ k ] else : for m in range ( k 5,k +5,1): Y[ k ] += 1/(2 r ) sunspotn [m] #P l o t t i n g monthn = 1000 p l t. x l a b e l ( Time [ month #] ) p l t. y l a b e l ( Number o f sunspots ) p l t. p l o t ( time [ 0 : monthn ], sunspotn [ 0 : monthn ], b, time [ 0 : monthn ], Y[ 0 : monthn ], r s ) 3

4 Figure 1: Daw, I love you too! 2 Curve plotting 2.1 Deltoid curve plot Plot the parametric equations x = 2 cos θ + cos 2θ, y = 2 sin θ sin2θ where 0 θ < 2π. Take a set of values of θ between zero and 2π, and calculate x and y for each from the equations above, then plot y as a function of x. We get Fig. 1 from the script from math import sin, cos, pi from numpy import l i n s p a c e, s i z e, z e r o s l e n = 100 x, y = z e r o s ( l e n ), z e r o s ( l e n ) theta = l i n s p a c e (0,2 pi, l e n ) for j in range ( 0, s i z e ( theta ) ) : x [ j ] = 2 cos ( theta [ j ] ) + cos (2 theta [ j ] ) y [ j ] = 2 s i n ( theta [ j ] ) + s i n (2 theta [ j ] ) p l t. x l a b e l ( x ) p l t. y l a b e l ( y ) p l t. p l o t ( x, y, bs ) 4

5 2.2 Plotting the Galilean spiral, r = θ 2 for 0 θ 24π. is generated from from math import sin, cos, pi from numpy import l i n s p a c e, s i z e, z e r o s l e n = 1000 x, y, r = z e r o s ( l e n ), z e r o s ( l e n ), z e r o s ( l e n ) theta = l i n s p a c e (0,10 pi, l e n ) for j in range ( 0, s i z e ( theta ) ) : r [ j ] = theta [ j ] 2 x [ j ] = r [ j ] cos ( theta [ j ] ) y [ j ] = r [ j ] s i n ( theta [ j ] ) p l t. x l a b e l ( x ) p l t. y l a b e l ( y ) p l t. p l o t ( x, y, r ) 2.3 Fey s function polar plot Using the script from math import sin, cos, exp, pi from numpy import l i n s p a c e, s i z e, z e r o s 5

6 l e n = x, y, r = z e r o s ( l e n ), z e r o s ( l e n ), z e r o s ( l e n ) theta = l i n s p a c e (0,24 pi, l e n ) for j in range ( 0, s i z e ( theta ) ) : r [ j ] = exp ( cos ( theta [ j ] ) ) 2 cos (4 theta [ j ] ) + \ s i n ( theta [ j ] / 1 2 ) 5 x [ j ] = r [ j ] cos ( theta [ j ] ) y [ j ] = r [ j ] s i n ( theta [ j ] ) p l t. x l a b e l ( x ) p l t. y l a b e l ( y ) p l t. p l o t ( x, y, r ) we generate 3 Plotting atomic lattice (VPython) This is the one that I m skipping/avoiding because I already did it in the notes, to generate 6

7 which is an approximate NaCl lattice. Doing a FCC (face-centered cubic) lattice would be a question of adding another atom 2a/2 offset on the diagonal from the central atom. 4 Deterministic chaos and the Feigenbaum plot Consider the logistic map, defined by x0 = rx(1 x). For a given constant r take a value of x, say x = 1/2, and feed it into the RHS of this equation to get x0. Then take the value you get, feed it back in, and so on. I.e., you iterate. One of three things will happen: 1. The value settles down to a fixed number, and stays there. For instance, x = 0 is one such fixed point of the logistic map. 2. You never settle to a single value, but instead settle into a periodic pattern, rotating around a set number of values, repeating them in sequence forever. This is a limit cycle. 3. It goes crazy. It generates a seemingly random sequence of numbers that appear to have no rhyme or reason to them at all. This is deterministic chaos, in the sense that it really does look chaotic, but deterministic because we know that the values have a rule behind them. The behavior is determined, it just isn t obvious that this is the case. We write a program to calculate and display the behavior of the logistic map: import m a t p l o t l i b. p y p l o t a s p l t from numpy import l i n s p a c e, s i z e #Returns r e s u l t o f n o p e r a t i o n s o f l o g i s t i c map on x, g i v e n r def l o g i s t i c M a p ( r, x, n ) : i, xprime = 0, 0. 7

8 while i < n : xprime = r x (1 x ) x = xprime i += 1 return xprime #Returns l i s t o f l a t t e r 1000 mappings to p l o t def g e t X l i s t ( r, x ) : i = 0 while i < 250: x. append ( l o g i s t i c M a p ( r, x [ s i z e ( x ) 1], 1 ) ) i += 1 return x xmin, xmax = , 3.86 for r in l i n s p a c e ( xmin, xmax, ) : print ( r ) x = [ l o g i s t i c M a p ( r, 1/2, ) ] x = g e t X l i s t ( r, x ) for i in range ( s i z e ( x ) ) : p l t. s c a t t e r ( r, x [ i ], 1) p l t. x l a b e l ( r ) p l t. y l a b e l ( x ( Orbit ) ) p l t. t i t l e ( L o g i s t i c Map ( Feigenbaum Plot ) ) p l t. a x i s ( [ xmin, xmax, 0, 1 ] ) which, once plotted in Figs. 2 and 3 gives pretty nice results. Answering the questions: a) Fixed points look like single orbits (values of x) corresponding to single values of r. Limit cycles are when two or more values of x correspond to a single value of r. Chaos is when a seemingly random large number of x points are given by a single value of r. b) The switch from orderly (fixed points, limit cycles) to chaotic happens roughly at r = (obviously, wiki). Aside: This deterministic chaos is seen in more complex physical systems too, most notably fluid dynamics and the weather. We get an idea through these plots of what chaotic behavior means: change initial conditions by just a little, and you ll get a rapid onset of highly diverse, hard-to-predict results. The classic example is Edward Lorenz s butterfly effect (although scifi writer Ray Bradbury may have suggested the idea in a story 25 years earlier). We can definitely go further than these two figures though. Generating them with roughly 10 6 points took upwards of ten minutes on my laptop, and we should be able to do much better. Noting the hint at the end of the problem to vectorize the code, we rewrite the whole program and find nicer results: from numpy import l i n s p a c e, array, vstack, f u l l, copy #Returns r e s u l t o f n o p e r a t i o n s o f l o g i s t i c map on x, given r 8

9 Figure 2: The logistic map, x n+1 = rx n (1 x n ), for 2.8 r 4.0. def l o g i s t i c M a p ( r, x, n ) : i, xprime = 0, 0. while i < n : xprime = r x (1 x ) x = xprime i += 1 return xprime #Returns f u l l matrix o f x v a l u e s with each map i t e r a t i o n f o r numx def getmatrix ( r, x, numx) : i = 0 while i < numx: i f i == 0 : #obnoxious, but seemed necessary x = vstack ( ( x, l o g i s t i c M a p ( r, x, 1 ) ) ) else : x = vstack ( ( x [ 0 : i, : ], l o g i s t i c M a p ( r, x [ i 1, : ], 1 ) ) ) i += 1 return x numr = 1000 #number o f r v a l u e s numx = 1000 #number o f x v a l u e s f o r each r v a l u e rmin, rmax = 2. 2, 3 #r between min and max alp = 0.02 #from 0 to 1, changes c o n t r a s t o f p l o t t e d p t s 9

10 Figure 3: The logistic map in the first large island of stability, which begins at r = l i n s p a c e ( rmin, rmax, numr) x = array ( [ 1 / 2 ] numr) x = l o g i s t i c M a p ( r, x, 1000) #s t a b i l i z e s t a r t i n g v a l u e s over 1000 i t e r a t i o n s x = getmatrix ( r, x, numx) #g e t the data o f x o r b i t s f o r each r ( v e c t o r i z e d ) print ( Got matrix, now p l o t t i n g. ) rarr = f u l l ( (numx,numr), 1. ) #used to v e c t o r i z e s c a t t e r p l o t for i in range (numx) : rarr [ i, : ] = copy ( r ) p l t. x l a b e l ( r ) p l t. y l a b e l ( x ( Orbit ) ) p l t. t i t l e ( L o g i s t i c Map ( Feigenbaum Plot ) ) p l t. a x i s ( [ rmin, rmax, 0, 1 ] ) p l t. s c a t t e r ( rarr, x, s =4, alpha=alp ) This program runs like, at least a factor of 100 faster than the other. So obviously we push it further, and make more plots: 10

11 Figure 4: More points. Figure 5: Getting artistic. 11

12 5 Least squares and the photoelectric effect This is the method of least squares. If we have N data points with coordinates (x i, y i ), then the sum of the squares of the distances between some guess line y = mx + c and the points is χ 2 = N (mx i + c y i ) 2 = i=1 N m 2 x 2 i + c 2 + yi 2 + 2mx i c 2mx i y i 2cy i. i=1 The least squares fit is the line that minimizes χ 2. Find this minimum by differentiating with respect to both m and c, and setting the derivatives to zero: N N N m x 2 i + c x i x i y i = 0 i=1 i=1 i=1 N N m x i + cn y i = 0. i=1 i=1 For convenience, define E x = 1 N N x i, i=1 E y = 1 N N i=1 y i, E xx = 1 N N x 2 i, i=1 E xy = 1 N N x i y i, i=1 so that we can rewrite our equations Solving simultaneously for m and c gives m = E xy E x E y E xx E 2 x me xx + ce x = E xy me x + c = E y., c = E xxe y E x E xy E xx Ex 2. These are the equations for the least-squares fit of a straight line to N data points. They give the values of m and c for the last line that best fits the given data. 5.1 Millikan: read data points, make graph from numpy import l o a d t x t data = l o a d t x t ( m i l l i k a n. txt, f l o a t ) x = data [ :, 0 ] y = data [ :, 1 ] p l t. p l o t ( x, y, k. ) 5.2 Find E y, E x x, E x y and print m,c of best-fit line 12

13 N = s i z e ( x ) E x = 1/N sum( x ) E y = 1/N sum( y ) E xx = 1/N sum( x 2) E xy = 1/N sum( x y ) m = ( E xy E x E y ) / ( E xx E x 2) c = ( E xx E y E x E xy ) / ( E xx E x 2) print ( m=%.3 f % m, c=%.3 f % c ) 5.3 Draw straight line Draw the straight line by evaluating mx i + c using the values of m, c from the previous part. Store these values to a list or array, then graph this array as a solid line. This gives a program: from numpy import loadtxt, s i z e data = l o a d t x t ( m i l l i k a n. txt, f l o a t ) x = data [ :, 0]/1 e15 y = data [ :, 1 ] N = s i z e ( x ) E x = sum( x ) / N E y = sum( y ) / N E xx = sum( x 2) / N E xy = sum( x y ) / N m = ( E xy E x E y ) / ( E xx E x E x ) c = ( E xx E y E x E xy ) / ( E xx E x 2) b e s t F i t = m x + c print ( m=%.3 f % m, c=%.3 f % c ) p l t. p l o t ( x, y, k. ) p l t. p l o t ( x, b e s t F i t ) 13

14 5.4 Calculating Planck s constant Given that this data is actually of a photoelectric experiment, where the voltage required to stop ejected electrons, V, is measured as a function of ν, the frequency of incoming light, so our equation y = mx + c actually is V = h e ν φ, so that y = V, m = h/e, c = φ. We are given that e = C, and since we have m = VHz 1, we can calculate h = m e = = VCs = Js which is indeed within a few percent of the literature value. 6 Trapezoidal rule and Romberg rule for integrals Evaluate I = 1 0 sin 2 100x dx 6.1 Use the trapezoidal rule to calculate it to accuracy ε = 10 6 The approximation used in the trapezoidal rule integrating f over [a, b] is ( 1 I h 2 f(a) + 1 N ) 2 f(b) + f(a + kh), for ε = 1 12 h2 (f (a) f (b)). For us, f(x) = sin 2 100x, so f (x) = d dx (sin 100x sin 100x) = 10x 1/2 cos 100x sin 100x, which simplified is 5 sin (20 x)/ x and to avoid dividing by zero, 5 sin(20 x)/ x = 5 ( 20 x (20 x) 3 x 3! k=1 + (20 x) 5 5! (20 x) 7 7! + (20 x) 9 9! ( = x x x x x 5 + O(x 5 ) 3! 5! 7! 9! 11! ) + O(x 11/2 ) which we implement to be accurate up to O(x 6 ) to avoid the division by zero. The program we write is from numpy import sin, s q r t def f a c t o r i a l ( x ) : i f x == 1 : return 1 else : return x f a c t o r i a l ( x 1) ) 14

15 def f ( x ) : return s i n ( s q r t (100 x )) 2 def fprime ( x ) : return 5 ( x/ f a c t o r i a l ( 3 ) x 2/ f a c t o r i a l ( 5 ) 20 7 x 3/ f a c t o r i a l ( 7 ) x 4/ f a c t o r i a l ( 9 ) x 5/ f a c t o r i a l ( 1 1 ) ) def eps (h, a, b ) : return h 2 ( fprime ( a ) fprime ( b ) ) / 12 a, b, I = 0, 1, 0. for i in range ( 5 0 ) : N = 2 i h = (b a )/N e r r o r = eps (h, a, b ) print ( i, h, e r r o r ) i f e r r o r < 1e 6: I = h ( f ( a )/2 + f ( b )/2) for k in range ( 1,N) : I += h f ( a+k h ) break print ( I ) which results I = , good to Mathematica s result to 10 decimals! 6.2 Romberg technique Honestly I can t be bothered here. Gaussian stuff in any case. Looks pretty boring, and we can just do the higher-order 7 Heat capacity of a solid Debye s theory of solids gives the heat capacity of a solid at temperature T to be C V = 9V ρk B θd /T 0 x 4 e x (e x 1) 2 dx, for V the volume of the solid, ρ the number density of atoms, and θ D the Debye temperature, a property of solids that depends on their density and the speed of sound. a) Write a function cv(t) that calculates C V for a given value of the temperature, for a sample of 1000 cm 3 = 10 3 m 3 of solid Al, which has number density ρ = m 3, and θ D = 428K. Use Gaussian quadrature to evaluate the integral, with N = 50 sample points. 15

16 from numpy import exp, l i n s p a c e from gaussxw import gaussxw, gaussxwab def f ( x ) : return x 4 exp ( x ) / ( exp ( x) 1) 2 def cv (T) : V = 1e 3 #m 3 rho = e28 #1/m 3 kb = e 23 #J/K thetad = 428 p r e f a c = 9 V rho kb (T/ thetad ) 3 #Get p o i n t s and w e i g h t s f o r i n t e g r a l N = 50 a, b = 0., thetad /T xp, wp = gaussxwab (N, a, b ) #Perform i n t e g r a t i o n s = 0. for k in range (N) : s += wp [ k ] f ( xp [ k ] ) #p r i n t ( s ) return p r e f a c s T = l i n s p a c e ( 5, 5 0 0, ) c v L i s t = [ ] for i in range ( ) : c v L i s t. append ( cv (T[ i ] ) ) p l t. p l o t (T, c v L i s t ) p l t. x l a b e l ( Temperature $ [K] $ ) p l t. y l a b e l ( Heat c a p a c i t y $C V$ $ [ J /( kg\ cdot K) ] $ ) p l t. t i t l e ( $C v (T) $ o f Aluminum, Debye P r e d i c t i o n ) gives the figure 16

17 17